Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rework llindexedvector to be a bit more debugable.

Browse Source
This commit is contained in:
Shyotl
2019-07-10 01:05:42 -05:00
parent 37839ff247
commit 49b027f2a0
6 changed files with 168 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
indra/llcommon/llindexedvector.h
View File

@@ -36,8 +36,8 @@
// LLIndexedVector
//--------------------------------------------------------
template <typename Type, typename Key, int BlockSize = 32>
class LLIndexedVector
template <typename Type, typename Key, int BlockSize = 32>
class LLIndexedVector1
{
public:
typedef typename std::vector<std::pair<Key, Type> > vec_type_t;
@@ -50,7 +50,10 @@ protected:
std::vector<std::pair<Key, Type> > mVector;
public:
LLIndexedVector() { mVector.reserve(BlockSize); }
LLIndexedVector1() { mVector.reserve(BlockSize); }
const Type& toValue(const_iterator& iter) const { return iter->second; }
Type& toValue(iterator& iter) { return iter->second; }
iterator begin() { return mVector.begin(); }
const_iterator begin() const { return mVector.begin(); }
@@ -75,6 +78,125 @@ public:
{
return std::find_if(mVector.begin(), mVector.end(), [&k](const typename vec_type_t::value_type& e) { return e.first == k; });
}
typedef DeletePairedPointer DeletePointer;
};
template <typename Type, typename Key, int BlockSize = 32>
class LLIndexedVector2
{
public:
typedef typename std::vector<Type>::iterator iterator;
typedef typename std::vector<Type>::const_iterator const_iterator;
typedef typename std::vector<Type>::reverse_iterator reverse_iterator;
typedef typename std::vector<Type>::const_reverse_iterator const_reverse_iterator;
typedef typename std::vector<Type>::size_type size_type;
protected:
std::vector<Type> mVector;
std::map<Key, U32> mIndexMap;
#ifdef DEBUG_LLINDEXEDVECTOR
LLIndexedVector1<Type*, Key, BlockSize> mCopy;
#endif
public:
LLIndexedVector2() { mVector.reserve(BlockSize); }
const Type& toValue(const_iterator& iter) const { return *iter; }
Type& toValue(iterator& iter) { return *iter; }
iterator begin() { return mVector.begin(); }
const_iterator begin() const { return mVector.begin(); }
iterator end() { return mVector.end(); }
const_iterator end() const { return mVector.end(); }
reverse_iterator rbegin() { return mVector.rbegin(); }
const_reverse_iterator rbegin() const { return mVector.rbegin(); }
reverse_iterator rend() { return mVector.rend(); }
const_reverse_iterator rend() const { return mVector.rend(); }
void reset() {
#ifdef DEBUG_LLINDEXEDVECTOR
mCopy.reset();
#endif
mVector.resize(0);
mIndexMap.resize(0);
}
bool empty() const { return mVector.empty(); }
size_type size() const { return mVector.size(); }
void verify() const
{
#ifdef DEBUG_LLINDEXEDVECTOR
llassert_always(mCopy.empty() == empty());
llassert_always(mCopy.size() == size());
auto it2 = mCopy.begin();
int index = 0;
for (auto it1 = begin(); it1 != end(); ++it1)
{
llassert_always(it2->second == &*it1);
++it2;
++index;
}
for (auto it = mIndexMap.begin(); it != mIndexMap.end(); ++it)
{
auto i = it->second;
llassert_always((mCopy.begin() + i)->first == it->first);
llassert_always((mCopy.begin() + i)->second == &mVector[i]);
}
#endif
}
Type& operator[](const Key& k)
{
verify();
typename std::map<Key, U32>::const_iterator iter = mIndexMap.find(k);
if (iter == mIndexMap.end())
{
U32 n = mVector.size();
mIndexMap[k] = n;
mVector.push_back(Type());
llassert(mVector.size() == mIndexMap.size());
#ifdef DEBUG_LLINDEXEDVECTOR
mCopy[k] = &mVector[n];
auto it2 = mCopy.begin();
for (auto it1 = begin(); it1 != end(); ++it1)
{
it2->second = &(*it1);
++it2;
}
#endif
return mVector[n];
}
else
{
return mVector[iter->second];
}
}
const_iterator find(const Key& k) const
{
verify();
typename std::map<Key, U32>::const_iterator iter = mIndexMap.find(k);
if(iter == mIndexMap.end())
{
return mVector.end();
}
else
{
return mVector.begin() + iter->second;
}
}
typedef DeletePointer DeletePointer;
};
template <typename Type, typename Key, int BlockSize = 32>
#ifdef DEBUG_LLINDEXEDVECTOR
using LLIndexedVector = LLIndexedVector2<Type, Key, BlockSize>;
#else
using LLIndexedVector = LLIndexedVector1<Type, Key, BlockSize>;
#endif
#endif

6
indra/llmessage/llmessagetemplate.cpp
View File

@@ -125,8 +125,8 @@ std::ostream& operator<<(std::ostream& s, LLMessageBlock &msg)
for (LLMessageBlock::message_variable_map_t::iterator iter = msg.mMemberVariables.begin();
iter != msg.mMemberVariables.end(); iter++)
{
LLMessageVariable& ci = *iter->second;
s << ci;
LLMessageVariable* ci = msg.mMemberVariables.toValue(iter);
s << *ci;
}
return s;
@@ -169,7 +169,7 @@ std::ostream& operator<<(std::ostream& s, LLMessageTemplate &msg)
for (LLMessageTemplate::message_block_map_t::iterator iter = msg.mMemberBlocks.begin();
iter != msg.mMemberBlocks.end(); iter++)
{
LLMessageBlock* ci = iter->second;
LLMessageBlock* ci = msg.mMemberBlocks.toValue(iter);
s << *ci;
}

29
indra/llmessage/llmessagetemplate.h
View File

@@ -90,7 +90,7 @@ public:
for (msg_var_data_map_t::iterator iter = mMemberVarData.begin();
iter != mMemberVarData.end(); iter++)
{
iter->second.deleteData();
mMemberVarData.toValue(iter).deleteData();
}
}
@@ -123,6 +123,7 @@ public:
~LLMsgData()
{
for_each(mMemberBlocks.begin(), mMemberBlocks.end(), DeletePairedPointer());
mMemberBlocks.clear();
}
void addBlock(LLMsgBlkData *blockp)
@@ -190,21 +191,21 @@ public:
~LLMessageBlock()
{
for_each(mMemberVariables.begin(), mMemberVariables.end(), DeletePairedPointer());
for_each(mMemberVariables.begin(), mMemberVariables.end(), message_variable_map_t::DeletePointer());
}
void addVariable(char *name, const EMsgVariableType type, const S32 size)
{
LLMessageVariable** varp = &mMemberVariables[name];
if (*varp != NULL)
LLMessageVariable*& varp = mMemberVariables[name];
if (varp != NULL)
{
LL_ERRS() << name << " has already been used as a variable name!" << LL_ENDL;
}
*varp = new LLMessageVariable(name, type, size);
if (((*varp)->getType() != MVT_VARIABLE)
&&(mTotalSize != -1))
varp = new LLMessageVariable(name, type, size);
if ((varp->getType() != MVT_VARIABLE)
&& (mTotalSize != -1))
{
mTotalSize += (*varp)->getSize();
mTotalSize += varp->getSize();
}
else
{
@@ -225,7 +226,7 @@ public:
const LLMessageVariable* getVariable(char* name) const
{
message_variable_map_t::const_iterator iter = mMemberVariables.find(name);
return iter != mMemberVariables.end()? iter->second : NULL;
return iter != mMemberVariables.end() ? mMemberVariables.toValue(iter) : NULL;
}
friend std::ostream& operator<<(std::ostream& s, LLMessageBlock &msg);
@@ -297,18 +298,18 @@ public:
~LLMessageTemplate()
{
for_each(mMemberBlocks.begin(), mMemberBlocks.end(), DeletePairedPointer());
for_each(mMemberBlocks.begin(), mMemberBlocks.end(), message_block_map_t::DeletePointer());
}
void addBlock(LLMessageBlock *blockp)
{
LLMessageBlock** member_blockp = &mMemberBlocks[blockp->mName];
if (*member_blockp != NULL)
LLMessageBlock*& member_blockp = mMemberBlocks[blockp->mName];
if (member_blockp != NULL)
{
LL_ERRS() << "Block " << blockp->mName
<< "has already been used as a block name!" << LL_ENDL;
}
*member_blockp = blockp;
member_blockp = blockp;
if ( (mTotalSize != -1)
&&(blockp->mTotalSize != -1)
&&( (blockp->mType == MBT_SINGLE)
@@ -391,7 +392,7 @@ public:
const LLMessageBlock* getBlock(char* name) const
{
message_block_map_t::const_iterator iter = mMemberBlocks.find(name);
return iter != mMemberBlocks.end() ? iter->second : NULL;
return iter != mMemberBlocks.end()? mMemberBlocks.toValue(iter): NULL;
}
public:

2
indra/llmessage/llsdmessagebuilder.cpp
View File

@@ -257,7 +257,7 @@ void LLSDMessageBuilder::copyFromMessageData(const LLMsgData& data)
for(; dit != dend; ++dit)
{
const LLMsgVarData& mvci = dit->second;
const LLMsgVarData& mvci = mbci->mMemberVarData.toValue(dit);
const char* varname = mvci.getName();
switch(mvci.getType())

17
indra/llmessage/lltemplatemessagebuilder.cpp
View File

@@ -89,7 +89,7 @@ void LLTemplateMessageBuilder::newMessage(const char *name)
iter != msg_template->mMemberBlocks.end();
++iter)
{
LLMessageBlock* ci = iter->second;
const LLMessageBlock* ci = msg_template->mMemberBlocks.toValue(iter);
LLMsgBlkData* tblockp = new LLMsgBlkData(ci->mName, 0);
mCurrentSMessageData->addBlock(tblockp);
}
@@ -151,8 +151,8 @@ void LLTemplateMessageBuilder::nextBlock(const char* blockname)
for (LLMessageBlock::message_variable_map_t::const_iterator iter = template_data->mMemberVariables.begin();
iter != template_data->mMemberVariables.end(); iter++)
{
LLMessageVariable& ci = *iter->second;
mCurrentSDataBlock->addVariable(ci.getName(), ci.getType());
const LLMessageVariable* ci = template_data->mMemberVariables.toValue(iter);
mCurrentSDataBlock->addVariable(ci->getName(), ci->getType());
}
return;
}
@@ -212,8 +212,8 @@ void LLTemplateMessageBuilder::nextBlock(const char* blockname)
end = template_data->mMemberVariables.end();
iter != end; iter++)
{
LLMessageVariable& ci = *iter->second;
mCurrentSDataBlock->addVariable(ci.getName(), ci.getType());
const LLMessageVariable* ci = template_data->mMemberVariables.toValue(iter);
mCurrentSDataBlock->addVariable(ci->getName(), ci->getType());
}
return;
}
@@ -602,7 +602,7 @@ static S32 buildBlock(U8* buffer, S32 buffer_size, const LLMessageBlock* templat
for (LLMsgBlkData::msg_var_data_map_t::const_iterator iter = mbci->mMemberVarData.begin();
iter != mbci->mMemberVarData.end(); iter++)
{
const LLMsgVarData& mvci = iter->second;
const LLMsgVarData& mvci = mbci->mMemberVarData.toValue(iter);
if (mvci.getSize() == -1)
{
// oops, this variable wasn't ever set!
@@ -758,7 +758,8 @@ U32 LLTemplateMessageBuilder::buildMessage(
iter != end;
++iter)
{
result += buildBlock(buffer + result, buffer_size - result, iter->second, mCurrentSMessageData);
const LLMessageBlock* block = mCurrentSMessageTemplate->mMemberBlocks.toValue(iter);
result += buildBlock(buffer + result, buffer_size - result, block, mCurrentSMessageData);
}
mbSBuilt = TRUE;
@@ -801,7 +802,7 @@ void LLTemplateMessageBuilder::copyFromMessageData(const LLMsgData& data)
for(; dit != dend; ++dit)
{
const LLMsgVarData& mvci = dit->second;
const LLMsgVarData& mvci = mbci->mMemberVarData.toValue(dit);
addData(mvci.getName(), mvci.getData(), mvci.getType(), mvci.getSize());
}
}

30
indra/llmessage/lltemplatemessagereader.cpp
View File

@@ -554,7 +554,7 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender,
iter != mCurrentRMessageTemplate->mMemberBlocks.end();
++iter)
{
LLMessageBlock* mbci = iter->second;
const LLMessageBlock* mbci = mCurrentRMessageTemplate->mMemberBlocks.toValue(iter);
U8 repeat_number;
S32 i;
@@ -621,17 +621,17 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender,
mbci->mMemberVariables.begin();
iter != mbci->mMemberVariables.end(); iter++)
{
const LLMessageVariable& mvci = *iter->second;
const LLMessageVariable* mvci = mbci->mMemberVariables.toValue(iter);
// ok, build out the variables
// add variable block
cur_data_block->addVariable(mvci.getName(), mvci.getType());
cur_data_block->addVariable(mvci->getName(), mvci->getType());
// what type of variable?
if (mvci.getType() == MVT_VARIABLE)
if (mvci->getType() == MVT_VARIABLE)
{
// variable, get the number of bytes to read from the template
S32 data_size = mvci.getSize();
S32 data_size = mvci->getSize();
U8 tsizeb = 0;
U16 tsizeh = 0;
U32 tsize = 0;
@@ -666,32 +666,32 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender,
}
decode_pos += data_size;
cur_data_block->addData(mvci.getName(), &buffer[decode_pos], tsize, mvci.getType());
cur_data_block->addData(mvci->getName(), &buffer[decode_pos], tsize, mvci->getType());
decode_pos += tsize;
}
else
{
// fixed!
// so, copy data pointer and set data size to fixed size
if ((decode_pos + mvci.getSize()) > mReceiveSize)
if ((decode_pos + mvci->getSize()) > mReceiveSize)
{
if(!custom)
logRanOffEndOfPacket(sender, decode_pos, mvci.getSize());
logRanOffEndOfPacket(sender, decode_pos, mvci->getSize());
// default to 0s.
U32 size = mvci.getSize();
U32 size = mvci->getSize();
std::vector<U8> data(size, 0);
cur_data_block->addData(mvci.getName(), &(data[0]),
size, mvci.getType());
cur_data_block->addData(mvci->getName(), &(data[0]),
size, mvci->getType());
}
else
{
cur_data_block->addData(mvci.getName(),
cur_data_block->addData(mvci->getName(),
&buffer[decode_pos],
mvci.getSize(),
mvci.getType());
mvci->getSize(),
mvci->getType());
}
decode_pos += mvci.getSize();
decode_pos += mvci->getSize();
}
}
}