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

Merge branch 'animesh' of git://github.com/Shyotl/SingularityViewer into animesh

Browse Source
This commit is contained in:
Lirusaito
2019-07-10 03:43:44 -04:00
parent 94cf62f510 1234cf42e9
commit 6a60fa3458
9 changed files with 195 additions and 61 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

4
indra/llmessage/aicurl.cpp
View File

@@ -1077,7 +1077,7 @@ CURLcode CurlEasyRequest::curlCtxCallback(CURL* curl, void* sslctx, void* parm)
// Also turn off SSL v2, which is highly broken and strongly discouraged[1].
// [1] http://www.openssl.org/docs/ssl/SSL_CTX_set_options.html#SECURE_RENEGOTIATION
long options = SSL_OP_NO_SSLv2;
#ifdef SSL_OP_NO_TLSv1_1 // Only defined for openssl version 1.0.1 and up.
/*#ifdef SSL_OP_NO_TLSv1_1 // Only defined for openssl version 1.0.1 and up.
if (need_renegotiation_hack)
{
// This option disables openssl to use TLS version 1.1.
@@ -1095,7 +1095,7 @@ CURLcode CurlEasyRequest::curlCtxCallback(CURL* curl, void* sslctx, void* parm)
// This is expected when you compile against the headers of a version < 1.0.1 and then link at runtime with version >= 1.0.1.
// Don't do that.
llassert_always(!need_renegotiation_hack);
#endif
#endif*/
SSL_CTX_set_options(ctx, options);
return CURLE_OK;
}

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;
}

31
indra/llmessage/llmessagetemplate.h
View File

@@ -32,7 +32,7 @@
#include "llstl.h"
#include "llindexedvector.h"
#include <unordered_map>
#include <map>
extern U32 sMsgDataAllocSize;
extern U32 sMsgdataAllocCount;
@@ -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());
}
}

33
indra/llmessage/lltemplatemessagereader.cpp
View File

@@ -501,9 +501,10 @@ BOOL LLTemplateMessageReader::decodeTemplate(
else
{
if(!custom) {
// MAINT-7482 - make viewer more tolerant of unknown messages.
LL_WARNS() << "Message #" << std::hex << num << std::dec
<< " received but not registered!" << LL_ENDL;
gMessageSystem->callExceptionFunc(MX_UNREGISTERED_MESSAGE);
//gMessageSystem->callExceptionFunc(MX_UNREGISTERED_MESSAGE);
}
return(FALSE);
}
@@ -554,7 +555,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 +622,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 +667,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();
}
}
}

25
indra/newview/llfloatermessagelog.cpp
View File

@@ -86,11 +86,11 @@ LLFloaterMessageLogItem::LLFloaterMessageLogItem(LLMessageLogEntry entry)
mSummary.append(" ] ");
}
LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end();
for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin();
LLMessageTemplate::message_block_map_t::const_iterator blocks_end = temp->mMemberBlocks.end();
for (LLMessageTemplate::message_block_map_t::const_iterator blocks_iter = temp->mMemberBlocks.begin();
blocks_iter != blocks_end; ++blocks_iter)
{
LLMessageBlock* block = blocks_iter->second;
const LLMessageBlock* block = temp->mMemberBlocks.toValue(blocks_iter);
const char* block_name = block->mName;
S32 num_blocks = sTemplateMessageReader->getNumberOfBlocks(block_name);
if(!num_blocks)
@@ -100,11 +100,11 @@ LLFloaterMessageLogItem::LLFloaterMessageLogItem(LLMessageLogEntry entry)
else for(S32 i = 0; i < 1; i++)
{
mSummary.append(" { ");
LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end();
for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin();
LLMessageBlock::message_variable_map_t::const_iterator var_end = block->mMemberVariables.end();
for (LLMessageBlock::message_variable_map_t::const_iterator var_iter = block->mMemberVariables.begin();
var_iter != var_end; ++var_iter)
{
LLMessageVariable* variable = var_iter->second;
const LLMessageVariable* variable = block->mMemberVariables.toValue(var_iter);
const char* var_name = variable->getName();
BOOL returned_hex;
std::string value = getString(sTemplateMessageReader, block_name, i, var_name, variable->getType(), returned_hex, TRUE);
@@ -179,21 +179,22 @@ std::string LLFloaterMessageLogItem::getFull(BOOL show_header)
full.append(llformat("LL_RESENT_FLAG = %s\n", (mFlags & LL_RESENT_FLAG) ? "True" : "False"));
full.append(llformat("LL_ACK_FLAG = %s\n", (mFlags & LL_ACK_FLAG) ? "True" : "False"));
}
LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end();
for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin();
LLMessageTemplate::message_block_map_t::const_iterator blocks_end = temp->mMemberBlocks.end();
for (LLMessageTemplate::message_block_map_t::const_iterator blocks_iter = temp->mMemberBlocks.begin();
blocks_iter != blocks_end; ++blocks_iter)
{
LLMessageBlock* block = blocks_iter->second;
const LLMessageBlock* block = temp->mMemberBlocks.toValue(blocks_iter);
const char* block_name = block->mName;
S32 num_blocks = sTemplateMessageReader->getNumberOfBlocks(block_name);
for(S32 i = 0; i < num_blocks; i++)
{
full.append(llformat("[%s]\n", block->mName));
LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end();
for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin();
LLMessageBlock::message_variable_map_t::const_iterator var_end = block->mMemberVariables.end();
for (LLMessageBlock::message_variable_map_t::const_iterator var_iter = block->mMemberVariables.begin();
var_iter != var_end; ++var_iter)
{
LLMessageVariable* variable = var_iter->second;
const LLMessageVariable* variable = block->mMemberVariables.toValue(var_iter);
//LLMessageVariable* variable = var_iter->second;
const char* var_name = variable->getName();
BOOL returned_hex;
std::string value = getString(sTemplateMessageReader, block_name, i, var_name, variable->getType(), returned_hex);

10
indra/newview/llmakeoutfitdialog.cpp
View File

@@ -52,7 +52,15 @@ LLMakeOutfitDialog::LLMakeOutfitDialog(bool modal) : LLModalDialog(LLStringUtil:
// Build list of check boxes
for (S32 i = 0; i < LLWearableType::WT_COUNT; i++)
{
std::string name = std::string("checkbox_") + LLWearableType::getTypeLabel((LLWearableType::EType)i);
std::string label = LLWearableType::getTypeLabel((LLWearableType::EType)i);
std::string name = std::string("checkbox_") + label;
std::string labellower = label;
labellower[0] = tolower(labellower[0]);
std::string namelower = std::string("checkbox_") + labellower;
if (findChild<LLView>(namelower))
{
name = namelower;
}
mCheckBoxList.push_back(std::make_pair(name, i));
// Hide undergarments from teens
if (gAgent.isTeen() && ((LLWearableType::WT_UNDERSHIRT == (LLWearableType::EType)i) || (LLWearableType::WT_UNDERPANTS == (LLWearableType::EType)i)))