From b2028085fdfddfd5a7ac0f52d9f34b84457b3b98 Mon Sep 17 00:00:00 2001 From: Richard Nelson Date: Wed, 4 Aug 2010 19:02:30 -0700 Subject: first pass at faster XUI parsing (no recursion support yet) also made LLSD->param block parsing faster --- indra/llui/llsdparam.cpp | 116 ++++++++++++++++++++++++++++++++++++----------- 1 file changed, 89 insertions(+), 27 deletions(-) (limited to 'indra/llui/llsdparam.cpp') diff --git a/indra/llui/llsdparam.cpp b/indra/llui/llsdparam.cpp index 4bb45a3065..7d37127584 100644 --- a/indra/llui/llsdparam.cpp +++ b/indra/llui/llsdparam.cpp @@ -43,33 +43,16 @@ LLParamSDParser::LLParamSDParser() { using boost::bind; - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asInteger), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asInteger), - bind(&LLParamSDParser::writeU32Param, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asReal), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asReal), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asBoolean), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asString), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asUUID), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asDate), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readTypedValue, this, _1, &LLSD::asURI), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(bind(&LLParamSDParser::readSDParam, this, _1), - bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); -} - -bool LLParamSDParser::readSDParam(void* value_ptr) -{ - if (!mCurReadSD) return false; - *((LLSD*)value_ptr) = *mCurReadSD; - return true; + registerParserFuncs(readS32, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readU32, bind(&LLParamSDParser::writeU32Param, this, _1, _2)); + registerParserFuncs(readF32, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readF64, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readBool, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readString, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readUUID, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readDate, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readURI, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readSD, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); } // special case handling of U32 due to ambiguous LLSD::assign overload @@ -148,3 +131,82 @@ LLSD* LLParamSDParser::getSDWriteNode(const parser_t::name_stack_t& name_stack) return mWriteSD; } +bool LLParamSDParser::readS32(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((S32*)val_ptr) = self.mCurReadSD->asInteger(); + return true; +} + +bool LLParamSDParser::readU32(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((U32*)val_ptr) = self.mCurReadSD->asInteger(); + return true; +} + +bool LLParamSDParser::readF32(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((F32*)val_ptr) = self.mCurReadSD->asReal(); + return true; +} + +bool LLParamSDParser::readF64(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((F64*)val_ptr) = self.mCurReadSD->asReal(); + return true; +} + +bool LLParamSDParser::readBool(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((bool*)val_ptr) = self.mCurReadSD->asBoolean(); + return true; +} + +bool LLParamSDParser::readString(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((std::string*)val_ptr) = self.mCurReadSD->asString(); + return true; +} + +bool LLParamSDParser::readUUID(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((LLUUID*)val_ptr) = self.mCurReadSD->asUUID(); + return true; +} + +bool LLParamSDParser::readDate(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((LLDate*)val_ptr) = self.mCurReadSD->asDate(); + return true; +} + +bool LLParamSDParser::readURI(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((LLURI*)val_ptr) = self.mCurReadSD->asURI(); + return true; +} + +bool LLParamSDParser::readSD(Parser& parser, void* val_ptr) +{ + LLParamSDParser& self = static_cast(parser); + + *((LLSD*)val_ptr) = *self.mCurReadSD; + return true; +} -- cgit v1.2.3 From 65c9914d23022df6a39db50ce295750f08695893 Mon Sep 17 00:00:00 2001 From: Richard Nelson Date: Mon, 23 Aug 2010 11:03:19 -0700 Subject: made Params parsers not act as singletons --- indra/llui/llsdparam.cpp | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) (limited to 'indra/llui/llsdparam.cpp') diff --git a/indra/llui/llsdparam.cpp b/indra/llui/llsdparam.cpp index 7d37127584..338569fc58 100644 --- a/indra/llui/llsdparam.cpp +++ b/indra/llui/llsdparam.cpp @@ -36,23 +36,31 @@ // Project includes #include "llsdparam.h" +static LLInitParam::Parser::parser_read_func_map_t sReadFuncs; +static LLInitParam::Parser::parser_write_func_map_t sWriteFuncs; +static LLInitParam::Parser::parser_inspect_func_map_t sInspectFuncs; + // // LLParamSDParser // LLParamSDParser::LLParamSDParser() +: Parser(sReadFuncs, sWriteFuncs, sInspectFuncs) { using boost::bind; - registerParserFuncs(readS32, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readU32, bind(&LLParamSDParser::writeU32Param, this, _1, _2)); - registerParserFuncs(readF32, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readF64, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readBool, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readString, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readUUID, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readDate, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readURI, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readSD, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + if (sReadFuncs.empty()) + { + registerParserFuncs(readS32, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readU32, bind(&LLParamSDParser::writeU32Param, this, _1, _2)); + registerParserFuncs(readF32, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readF64, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readBool, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readString, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readUUID, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readDate, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readURI, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readSD, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + } } // special case handling of U32 due to ambiguous LLSD::assign overload -- cgit v1.2.3 From 0daa627db4f1bba2f69ec717426b26593674d14c Mon Sep 17 00:00:00 2001 From: Richard Nelson Date: Tue, 24 Aug 2010 11:44:28 -0700 Subject: removed LLLayoutStack::fromXML custom xml parsing --- indra/llui/llsdparam.cpp | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) (limited to 'indra/llui/llsdparam.cpp') diff --git a/indra/llui/llsdparam.cpp b/indra/llui/llsdparam.cpp index 338569fc58..69976004e6 100644 --- a/indra/llui/llsdparam.cpp +++ b/indra/llui/llsdparam.cpp @@ -50,25 +50,26 @@ LLParamSDParser::LLParamSDParser() if (sReadFuncs.empty()) { - registerParserFuncs(readS32, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readU32, bind(&LLParamSDParser::writeU32Param, this, _1, _2)); - registerParserFuncs(readF32, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readF64, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readBool, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readString, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readUUID, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readDate, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readURI, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); - registerParserFuncs(readSD, bind(&LLParamSDParser::writeTypedValue, this, _1, _2)); + registerParserFuncs(readS32, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readU32, &LLParamSDParser::writeU32Param); + registerParserFuncs(readF32, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readF64, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readBool, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readString, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readUUID, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readDate, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readURI, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readSD, &LLParamSDParser::writeTypedValue); } } // special case handling of U32 due to ambiguous LLSD::assign overload -bool LLParamSDParser::writeU32Param(const void* val_ptr, const parser_t::name_stack_t& name_stack) +bool LLParamSDParser::writeU32Param(LLParamSDParser::parser_t& parser, const void* val_ptr, const parser_t::name_stack_t& name_stack) { - if (!mWriteSD) return false; + LLParamSDParser& sdparser = static_cast(parser); + if (!sdparser.mWriteSD) return false; - LLSD* sd_to_write = getSDWriteNode(name_stack); + LLSD* sd_to_write = sdparser.getSDWriteNode(name_stack); if (!sd_to_write) return false; sd_to_write->assign((S32)*((const U32*)val_ptr)); -- cgit v1.2.3 From 3918b251e0f0405042ac8af6f5ff808bc2cc9553 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 14 Sep 2010 20:10:18 -0700 Subject: implemented param block -> LLSD serialization --- indra/llui/llsdparam.cpp | 99 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 95 insertions(+), 4 deletions(-) (limited to 'indra/llui/llsdparam.cpp') diff --git a/indra/llui/llsdparam.cpp b/indra/llui/llsdparam.cpp index bc1a0fd645..e3cadf4998 100644 --- a/indra/llui/llsdparam.cpp +++ b/indra/llui/llsdparam.cpp @@ -48,7 +48,7 @@ LLParamSDParser::LLParamSDParser() registerParserFuncs(readU32, &LLParamSDParser::writeU32Param); registerParserFuncs(readF32, &LLParamSDParser::writeTypedValue); registerParserFuncs(readF64, &LLParamSDParser::writeTypedValue); - registerParserFuncs(readBool, &LLParamSDParser::writeTypedValue); + registerParserFuncs(readBool, &LLParamSDParser::writeTypedValue); registerParserFuncs(readString, &LLParamSDParser::writeTypedValue); registerParserFuncs(readUUID, &LLParamSDParser::writeTypedValue); registerParserFuncs(readDate, &LLParamSDParser::writeTypedValue); @@ -61,7 +61,7 @@ LLParamSDParser::LLParamSDParser() bool LLParamSDParser::writeU32Param(LLParamSDParser::parser_t& parser, const void* val_ptr, const parser_t::name_stack_t& name_stack) { LLParamSDParser& sdparser = static_cast(parser); - if (!sdparser.mWriteSD) return false; + if (!sdparser.mWriteRootSD) return false; LLSD* sd_to_write = sdparser.getSDWriteNode(name_stack); if (!sd_to_write) return false; @@ -81,7 +81,8 @@ void LLParamSDParser::readSD(const LLSD& sd, LLInitParam::BaseBlock& block, bool void LLParamSDParser::writeSD(LLSD& sd, const LLInitParam::BaseBlock& block) { - mWriteSD = &sd; + mNameStack.clear(); + mWriteRootSD = &sd; block.serializeBlock(*this); } @@ -131,7 +132,97 @@ void LLParamSDParser::readSDValues(const LLSD& sd, LLInitParam::BaseBlock& block LLSD* LLParamSDParser::getSDWriteNode(const parser_t::name_stack_t& name_stack) { //TODO: implement nested LLSD writing - return mWriteSD; + LLSD* sd_to_write = mWriteRootSD; + bool new_traversal = false; + for (name_stack_t::const_iterator it = name_stack.begin(), prev_it = mNameStack.begin(); + it != name_stack.end(); + ++it) + { + bool new_array_entry = false; + if (prev_it == mNameStack.end()) + { + new_traversal = true; + } + else + { + if (!new_traversal // have not diverged yet from previous trace + && prev_it->first == it->first // names match + && prev_it->second != it->second) // versions differ + { + // name stacks match, but version numbers differ in last place. + // create a different entry at this point using an LLSD array + new_array_entry = true; + } + if (prev_it->first != it->first // names differ + || prev_it->second != it->second) // versions differ + { + // at this point we have diverged from our last trace + // so any elements referenced here are new + new_traversal = true; + } + } + + LLSD* child_sd = NULL; + if (it->first.empty()) + { + if (sd_to_write->isUndefined()) + { + *sd_to_write = LLSD::emptyArray(); + child_sd = sd_to_write; + } + else if (sd_to_write->isArray()) + { + child_sd = sd_to_write; + } + else + { + // go ahead and use the empty string as a map key + child_sd = &(*sd_to_write)[""]; + } + } + else + { + child_sd = &(*sd_to_write)[it->first]; + } + + if (child_sd->isArray()) + { + if (new_traversal) + { + // write to new element at end + sd_to_write = &(*child_sd)[child_sd->size()]; + } + else + { + // write to last of existing elements, or first element if empty + sd_to_write = &(*child_sd)[llmax(0, child_sd->size() - 1)]; + } + } + else + { + if (new_array_entry && !child_sd->isArray()) + { + // copy child contents into first element of an array + LLSD new_array = LLSD::emptyArray(); + new_array.append(*child_sd); + // assign array to slot that previously held the single value + *child_sd = new_array; + // return next element in that array + sd_to_write = &((*child_sd)[1]); + } + else + { + sd_to_write = child_sd; + } + } + if (prev_it != mNameStack.end()) + { + ++prev_it; + } + } + mNameStack = name_stack; + + return sd_to_write; } bool LLParamSDParser::readS32(Parser& parser, void* val_ptr) -- cgit v1.2.3 From f07c4f5bdc2358f65cc0aafe2b793c9854e0958a Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Thu, 16 Sep 2010 00:42:01 -0700 Subject: streamlined llsd serialization logic of param blocks --- indra/llui/llsdparam.cpp | 25 +++---------------------- 1 file changed, 3 insertions(+), 22 deletions(-) (limited to 'indra/llui/llsdparam.cpp') diff --git a/indra/llui/llsdparam.cpp b/indra/llui/llsdparam.cpp index e3cadf4998..f97f80ab6c 100644 --- a/indra/llui/llsdparam.cpp +++ b/indra/llui/llsdparam.cpp @@ -29,6 +29,7 @@ // Project includes #include "llsdparam.h" +#include "llsdutil.h" static LLInitParam::Parser::parser_read_func_map_t sReadFuncs; static LLInitParam::Parser::parser_write_func_map_t sWriteFuncs; @@ -162,28 +163,7 @@ LLSD* LLParamSDParser::getSDWriteNode(const parser_t::name_stack_t& name_stack) } } - LLSD* child_sd = NULL; - if (it->first.empty()) - { - if (sd_to_write->isUndefined()) - { - *sd_to_write = LLSD::emptyArray(); - child_sd = sd_to_write; - } - else if (sd_to_write->isArray()) - { - child_sd = sd_to_write; - } - else - { - // go ahead and use the empty string as a map key - child_sd = &(*sd_to_write)[""]; - } - } - else - { - child_sd = &(*sd_to_write)[it->first]; - } + LLSD* child_sd = &(*sd_to_write)[it->first]; if (child_sd->isArray()) { @@ -222,6 +202,7 @@ LLSD* LLParamSDParser::getSDWriteNode(const parser_t::name_stack_t& name_stack) } mNameStack = name_stack; + //llinfos << ll_pretty_print_sd(*mWriteRootSD) << llendl; return sd_to_write; } -- cgit v1.2.3