From 49b027f2a066e6cea7b285a3a046c04bf276d4ec Mon Sep 17 00:00:00 2001 From: Shyotl Date: Wed, 10 Jul 2019 01:05:42 -0500 Subject: [PATCH] Rework llindexedvector to be a bit more debugable. --- indra/llcommon/llindexedvector.h | 128 ++++++++++++++++++- indra/llmessage/llmessagetemplate.cpp | 6 +- indra/llmessage/llmessagetemplate.h | 29 +++-- indra/llmessage/llsdmessagebuilder.cpp | 2 +- indra/llmessage/lltemplatemessagebuilder.cpp | 17 +-- indra/llmessage/lltemplatemessagereader.cpp | 30 ++--- 6 files changed, 168 insertions(+), 44 deletions(-) diff --git a/indra/llcommon/llindexedvector.h b/indra/llcommon/llindexedvector.h index d2cee0f82..aa950eeb5 100644 --- a/indra/llcommon/llindexedvector.h +++ b/indra/llcommon/llindexedvector.h @@ -36,8 +36,8 @@ // LLIndexedVector //-------------------------------------------------------- -template -class LLIndexedVector +template +class LLIndexedVector1 { public: typedef typename std::vector > vec_type_t; @@ -50,7 +50,10 @@ protected: std::vector > 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 +class LLIndexedVector2 +{ +public: + typedef typename std::vector::iterator iterator; + typedef typename std::vector::const_iterator const_iterator; + typedef typename std::vector::reverse_iterator reverse_iterator; + typedef typename std::vector::const_reverse_iterator const_reverse_iterator; + typedef typename std::vector::size_type size_type; +protected: + std::vector mVector; + std::map mIndexMap; +#ifdef DEBUG_LLINDEXEDVECTOR + LLIndexedVector1 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::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::const_iterator iter = mIndexMap.find(k); + + if(iter == mIndexMap.end()) + { + return mVector.end(); + } + else + { + return mVector.begin() + iter->second; + } + } + + typedef DeletePointer DeletePointer; +}; + +template +#ifdef DEBUG_LLINDEXEDVECTOR +using LLIndexedVector = LLIndexedVector2; +#else +using LLIndexedVector = LLIndexedVector1; +#endif + #endif diff --git a/indra/llmessage/llmessagetemplate.cpp b/indra/llmessage/llmessagetemplate.cpp index 079814393..49ee1294b 100644 --- a/indra/llmessage/llmessagetemplate.cpp +++ b/indra/llmessage/llmessagetemplate.cpp @@ -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; } diff --git a/indra/llmessage/llmessagetemplate.h b/indra/llmessage/llmessagetemplate.h index 29b2be3b7..d9303505e 100644 --- a/indra/llmessage/llmessagetemplate.h +++ b/indra/llmessage/llmessagetemplate.h @@ -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: diff --git a/indra/llmessage/llsdmessagebuilder.cpp b/indra/llmessage/llsdmessagebuilder.cpp index 10819a24f..d65ab1bcf 100644 --- a/indra/llmessage/llsdmessagebuilder.cpp +++ b/indra/llmessage/llsdmessagebuilder.cpp @@ -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()) diff --git a/indra/llmessage/lltemplatemessagebuilder.cpp b/indra/llmessage/lltemplatemessagebuilder.cpp index 22afc23ce..ccc57796b 100644 --- a/indra/llmessage/lltemplatemessagebuilder.cpp +++ b/indra/llmessage/lltemplatemessagebuilder.cpp @@ -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()); } } diff --git a/indra/llmessage/lltemplatemessagereader.cpp b/indra/llmessage/lltemplatemessagereader.cpp index 9b2780162..9bd0986e3 100644 --- a/indra/llmessage/lltemplatemessagereader.cpp +++ b/indra/llmessage/lltemplatemessagereader.cpp @@ -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 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(); } } }