From f84a69a7e00f0eed49894e14336126849a9e7b29 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Thu, 27 Oct 2011 19:31:11 -0700 Subject: fixed build --- indra/llxuixml/llinitparam.h | 95 +------------------------------------------- 1 file changed, 1 insertion(+), 94 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 8f43cfb94f..183472450d 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -511,92 +511,6 @@ namespace LLInitParam const std::string& getParamName(const BlockDescriptor& block_data, const Param* paramp) const; }; - class BaseBlockWithFlags : public BaseBlock - { - public: - class FlagBase : public Param - { - public: - typedef FlagBase self_t; - - FlagBase(const char* name, BaseBlock* enclosing_block) : Param(enclosing_block) - { - if (LL_UNLIKELY(enclosing_block->mostDerivedBlockDescriptor().mInitializationState == BlockDescriptor::INITIALIZING)) - { - ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor( - enclosing_block->getHandleFromParam(this), - &mergeWith, - &deserializeParam, - &serializeParam, - NULL, - &inspectParam, - 0, 1)); - BaseBlock::addParam(enclosing_block->mostDerivedBlockDescriptor(), param_descriptor, name); - } - } - - bool isProvided() const { return anyProvided(); } - - private: - static bool mergeWith(Param& dst, const Param& src, bool overwrite) - { - const self_t& src_typed_param = static_cast(src); - self_t& dst_typed_param = static_cast(dst); - - if (src_typed_param.isProvided() - && (overwrite || !dst_typed_param.isProvided())) - { - dst.setProvided(true); - return true; - } - return false; - } - - static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation) - { - self_t& typed_param = static_cast(param); - - // no further names in stack, parse value now - if (name_stack.first == name_stack.second) - { - typed_param.setProvided(true); - typed_param.enclosingBlock().paramChanged(param, true); - return true; - } - - return false; - } - - static void serializeParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, const Param* diff_param) - { - const self_t& typed_param = static_cast(param); - const self_t* typed_diff_param = static_cast(diff_param); - - if (!typed_param.isProvided()) return; - - if (!name_stack.empty()) - { - name_stack.back().second = parser.newParseGeneration(); - } - - // then try to serialize value directly - if (!typed_diff_param || !typed_diff_param->isProvided()) - { - if (!parser.writeValue(NoParamValue(), name_stack)) - { - return; - } - } - } - - static void inspectParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, S32 min_count, S32 max_count) - { - // tell parser about our actual type - parser.inspectValue(name_stack, min_count, max_count, NULL); - } - }; - }; - // these templates allow us to distinguish between template parameters // that derive from BaseBlock and those that don't template @@ -1537,7 +1451,7 @@ namespace LLInitParam } }; - template + template class Block : public BASE_BLOCK { @@ -1633,13 +1547,6 @@ namespace LLInitParam }; - class Flag : public BaseBlockWithFlags::FlagBase - { - public: - Flag(const char* name) : FlagBase(name, DERIVED_BLOCK::selfBlockDescriptor().mCurrentBlockPtr) - {} - }; - template > class Multiple : public TypedParam { -- cgit v1.2.3 From 7e6e3d20f334547d8cea78e8e0b37106efebe028 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 8 Nov 2011 13:48:38 -0800 Subject: added Lazy modifier to params to support recursion ChoiceBlock can now derive from another param block Params with name/value support can be assigned directly in C++ code using param = "named_value" --- indra/llxuixml/llinitparam.h | 426 +++++++++++++++++++++++++++++++---------- indra/llxuixml/llxuiparser.cpp | 258 +++++++++++++++++++------ 2 files changed, 524 insertions(+), 160 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 183472450d..169a724bca 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -51,7 +51,7 @@ namespace LLInitParam return a == b; } }; - + // boost function types are not comparable template struct ParamCompare @@ -74,6 +74,7 @@ namespace LLInitParam static bool equals(const Flag& a, const Flag& b) { return false; } }; + // helper functions and classes typedef ptrdiff_t param_handle_t; @@ -82,8 +83,11 @@ namespace LLInitParam template class TypeValues { + private: + struct Inaccessable{}; public: typedef std::map value_name_map_t; + typedef Inaccessable name_t; void setValueName(const std::string& key) {} std::string getValueName() const { return ""; } @@ -113,6 +117,7 @@ namespace LLInitParam { public: typedef typename std::map value_name_map_t; + typedef std::string name_t; //TODO: cache key by index to save on param block size void setValueName(const std::string& value_name) @@ -293,36 +298,7 @@ namespace LLInitParam parser_inspect_func_map_t* mParserInspectFuncs; }; - class BaseBlock; - - class Param - { - public: - // public to allow choice blocks to clear provided flag on stale choices - void setProvided(bool is_provided) { mIsProvided = is_provided; } - - protected: - bool anyProvided() const { return mIsProvided; } - - Param(BaseBlock* enclosing_block); - - // store pointer to enclosing block as offset to reduce space and allow for quick copying - BaseBlock& enclosingBlock() const - { - const U8* my_addr = reinterpret_cast(this); - // get address of enclosing BLOCK class using stored offset to enclosing BaseBlock class - return *const_cast - (reinterpret_cast - (my_addr - (ptrdiff_t)(S32)mEnclosingBlockOffset)); - } - - private: - friend class BaseBlock; - - U32 mEnclosingBlockOffset:31; - U32 mIsProvided:1; - - }; + class Param; // various callbacks and constraints associated with an individual param struct ParamDescriptor @@ -390,12 +366,91 @@ namespace LLInitParam all_params_list_t mAllParams; // all parameters, owns descriptors size_t mMaxParamOffset; EInitializationState mInitializationState; // whether or not static block data has been initialized - BaseBlock* mCurrentBlockPtr; // pointer to block currently being constructed + class BaseBlock* mCurrentBlockPtr; // pointer to block currently being constructed }; class BaseBlock { public: + //TODO: implement in terms of owned_ptr + template + class Lazy + { + public: + Lazy() + : mPtr(NULL) + {} + + ~Lazy() + { + delete mPtr; + } + + Lazy(const Lazy& other) + { + if (other.mPtr) + { + mPtr = new T(*other.mPtr); + } + else + { + mPtr = NULL; + } + } + + Lazy& operator = (const Lazy& other) + { + if (other.mPtr) + { + mPtr = new T(*other.mPtr); + } + else + { + mPtr = NULL; + } + return *this; + } + + bool empty() const + { + return mPtr == NULL; + } + + void set(const T& other) + { + delete mPtr; + mPtr = new T(other); + } + + const T& get() const + { + return ensureInstance(); + } + + T& get() + { + return ensureInstance(); + } + + private: + // lazily allocate an instance of T + T* ensureInstance() const + { + if (mPtr == NULL) + { + mPtr = new T(); + } + return mPtr; + } + + private: + // if you get a compilation error with this, that means you are using a forward declared struct for T + // unfortunately, the type traits we rely on don't work with forward declared typed + //static const int dummy = sizeof(T); + + mutable T* mPtr; + }; + // "Multiple" constraint types, put here in root class to avoid ambiguity during use struct AnyAmount { @@ -511,6 +566,44 @@ namespace LLInitParam const std::string& getParamName(const BlockDescriptor& block_data, const Param* paramp) const; }; + template + struct ParamCompare, false > + { + static bool equals(const BaseBlock::Lazy& a, const BaseBlock::Lazy& b) { return !a.empty() || !b.empty(); } + }; + + class Param + { + public: + void setProvided(bool is_provided = true) + { + mIsProvided = is_provided; + enclosingBlock().paramChanged(*this, is_provided); + } + protected: + + bool anyProvided() const { return mIsProvided; } + + Param(BaseBlock* enclosing_block); + + // store pointer to enclosing block as offset to reduce space and allow for quick copying + BaseBlock& enclosingBlock() const + { + const U8* my_addr = reinterpret_cast(this); + // get address of enclosing BLOCK class using stored offset to enclosing BaseBlock class + return *const_cast + (reinterpret_cast + (my_addr - (ptrdiff_t)(S32)mEnclosingBlockOffset)); + } + + private: + friend class BaseBlock; + + U32 mEnclosingBlockOffset:31; + U32 mIsProvided:1; + + }; + // these templates allow us to distinguish between template parameters // that derive from BaseBlock and those that don't template @@ -530,6 +623,7 @@ namespace LLInitParam { public: typedef const T& value_assignment_t; + typedef ParamValue self_t; ParamValue(): mValue() {} ParamValue(value_assignment_t other) : mValue(other) {} @@ -559,6 +653,25 @@ namespace LLInitParam return mValue; } + void operator ()(const typename NAME_VALUE_LOOKUP::name_t& name) + { + *this = name; + } + + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) + { + if (NAME_VALUE_LOOKUP::getValueFromName(name, mValue)) + { + setValueName(name); + } + + return *this; + } + + self_t& operator =(const self_t& other) + { + mValue = other.mValue; + } private: T mValue; @@ -571,17 +684,16 @@ namespace LLInitParam { public: typedef const T& value_assignment_t; + typedef ParamValue self_t; ParamValue() : T(), - mKeyVersion(0), mValidatedVersion(-1), mValidated(false) {} ParamValue(value_assignment_t other) : T(other), - mKeyVersion(0), mValidatedVersion(-1), mValidated(false) {} @@ -611,8 +723,25 @@ namespace LLInitParam return *this; } - S32 mKeyVersion; + void operator ()(const typename NAME_VALUE_LOOKUP::name_t& name) + { + *this = name; + } + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) + { + if (NAME_VALUE_LOOKUP::getValueFromName(name, mValue)) + { + setValueName(name); + } + + return *this; + } + + self_t& operator =(const self_t& other) + { + *(static_cast(this)) = other; + } protected: mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag @@ -671,8 +800,7 @@ namespace LLInitParam if (parser.readValue(typed_param.getValue())) { typed_param.clearValueName(); - typed_param.setProvided(true); - typed_param.enclosingBlock().paramChanged(param, true); + typed_param.setProvided(); return true; } @@ -687,8 +815,7 @@ namespace LLInitParam if (name_value_lookup_t::getValueFromName(name, typed_param.getValue())) { typed_param.setValueName(name); - typed_param.setProvided(true); - typed_param.enclosingBlock().paramChanged(param, true); + typed_param.setProvided(); return true; } @@ -744,12 +871,22 @@ namespace LLInitParam } } + self_t& operator =(typename const name_value_lookup_t::name_t& name) + { + if (name_value_lookup_t::getValueFromName(name, getValue())) + { + setValueName(name); + setProvided(); + } + + return *this; + } + void set(value_assignment_t val, bool flag_as_provided = true) { setValue(val); param_value_t::clearValueName(); setProvided(flag_as_provided); - Param::enclosingBlock().paramChanged(*this, flag_as_provided); } protected: @@ -808,8 +945,7 @@ namespace LLInitParam if(typed_param.deserializeBlock(parser, name_stack_range, new_name)) { typed_param.clearValueName(); - typed_param.enclosingBlock().paramChanged(param, true); - typed_param.setProvided(true); + typed_param.setProvided(); return true; } @@ -822,10 +958,8 @@ namespace LLInitParam // try to parse a per type named value if (name_value_lookup_t::getValueFromName(name, typed_param.getValue())) { - typed_param.enclosingBlock().paramChanged(param, true); typed_param.setValueName(name); - typed_param.setProvided(true); - typed_param.mKeyVersion = typed_param.getLastChangeVersion(); + typed_param.setProvided(); return true; } @@ -845,7 +979,7 @@ namespace LLInitParam } std::string key = typed_param.getValueName(); - if (!key.empty() && typed_param.mKeyVersion == typed_param.getLastChangeVersion()) + if (!key.empty()) { if (!parser.writeValue(key, name_stack)) { @@ -888,19 +1022,33 @@ namespace LLInitParam // next call to isProvided() will update provision status based on validity param_value_t::mValidatedVersion = -1; setProvided(flag_as_provided); - Param::enclosingBlock().paramChanged(*this, flag_as_provided); + } + + self_t& operator =(typename const name_value_lookup_t::name_t& name) + { + if (name_value_lookup_t::getValueFromName(name, getValue())) + { + setValueName(name); + setProvided(); + } + + return *this; } // propagate changed status up to enclosing block /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { param_value_t::paramChanged(changed_param, user_provided); - Param::enclosingBlock().paramChanged(*this, user_provided); if (user_provided) { // a child param has been explicitly changed // so *some* aspect of this block is now provided - setProvided(true); + setProvided(); + param_value_t::clearValueName(); + } + else + { + Param::enclosingBlock().paramChanged(*this, user_provided); } } @@ -917,7 +1065,6 @@ namespace LLInitParam { dst_typed_param.clearValueName(); dst_typed_param.setProvided(true); - dst_typed_param.enclosingBlock().paramChanged(dst_typed_param, true); return true; } } @@ -1004,7 +1151,7 @@ namespace LLInitParam it != end_it; ++it) { - std::string key = it->getValue(); + std::string key = it->getValueName(); name_stack.back().second = true; if(key.empty()) @@ -1013,7 +1160,7 @@ namespace LLInitParam bool value_written = parser.writeValue(*it, name_stack); if (!value_written) { - std::string calculated_key = it->calcValueName(key); + std::string calculated_key = it->calcValueName(it->getValue()); if (!parser.writeValue(calculated_key, name_stack)) { break; @@ -1043,22 +1190,31 @@ namespace LLInitParam { mValues = val; setProvided(flag_as_provided); - Param::enclosingBlock().paramChanged(*this, flag_as_provided); } - value_t& add() + param_value_t& add() { mValues.push_back(param_value_t(value_t())); - setProvided(true); - Param::enclosingBlock().paramChanged(*this, true); + Param::setProvided(); return mValues.back(); } void add(const value_t& item) { mValues.push_back(param_value_t(item)); - setProvided(true); - Param::enclosingBlock().paramChanged(*this, true); + setProvided(); + } + + void add(typename const name_value_lookup_t::name_t& name) + { + value_t value; + + // try to parse a per type named value + if (name_value_lookup_t::getValueFromName(name, value)) + { + add(value); + mValues.back().setValueName(name); + } } // implicit conversion @@ -1099,8 +1255,7 @@ namespace LLInitParam if (src_typed_param.begin() != src_typed_param.end()) { - dst_typed_param.setProvided(true); - dst_typed_param.enclosingBlock().paramChanged(dst_typed_param, true); + dst_typed_param.setProvided(); } return true; } @@ -1116,7 +1271,7 @@ namespace LLInitParam public: typedef TypedParam self_t; typedef ParamValue param_value_t; - typedef typename std::vector container_t; + typedef typename std::vector container_t; typedef const container_t& value_assignment_t; typedef VALUE_TYPE value_t; typedef NAME_VALUE_LOOKUP name_value_lookup_t; @@ -1158,8 +1313,7 @@ namespace LLInitParam // attempt to parse block... if(value.deserializeBlock(parser, name_stack_range, new_name)) { - typed_param.enclosingBlock().paramChanged(param, true); - typed_param.setProvided(true); + typed_param.setProvided(); return true; } else if(name_value_lookup_t::valueNamesExist()) @@ -1172,9 +1326,7 @@ namespace LLInitParam if (name_value_lookup_t::getValueFromName(name, value.getValue())) { typed_param.mValues.back().setValueName(name); - typed_param.mValues.back().mKeyVersion = value.getLastChangeVersion(); - typed_param.enclosingBlock().paramChanged(param, true); - typed_param.setProvided(true); + typed_param.setProvided(); return true; } @@ -1201,7 +1353,7 @@ namespace LLInitParam name_stack.back().second = true; std::string key = it->getValueName(); - if (!key.empty() && it->mKeyVersion == it->getLastChangeVersion()) + if (!key.empty()) { parser.writeValue(key, name_stack); } @@ -1224,22 +1376,31 @@ namespace LLInitParam { mValues = val; setProvided(flag_as_provided); - Param::enclosingBlock().paramChanged(*this, flag_as_provided); } - value_t& add() + param_value_t& add() { mValues.push_back(value_t()); - setProvided(true); - Param::enclosingBlock().paramChanged(*this, true); + setProvided(); return mValues.back(); } void add(const value_t& item) { mValues.push_back(item); - setProvided(true); - Param::enclosingBlock().paramChanged(*this, true); + setProvided(); + } + + void add(typename const name_value_lookup_t::name_t& name) + { + value_t value; + + // try to parse a per type named value + if (name_value_lookup_t::getValueFromName(name, value)) + { + add(value); + mValues.back().setValueName(name); + } } // implicit conversion @@ -1288,8 +1449,7 @@ namespace LLInitParam if (src_typed_param.begin() != src_typed_param.end()) { - dst_typed_param.setProvided(true); - dst_typed_param.enclosingBlock().paramChanged(dst_typed_param, true); + dst_typed_param.setProvided(); } return true; @@ -1298,24 +1458,25 @@ namespace LLInitParam container_t mValues; }; - template - class ChoiceBlock : public BaseBlock + template + class ChoiceBlock : public BASE_BLOCK { - typedef ChoiceBlock self_t; - typedef ChoiceBlock enclosing_block_t; + typedef ChoiceBlock self_t; + typedef ChoiceBlock enclosing_block_t; + typedef BASE_BLOCK base_block_t; LOG_CLASS(self_t); public: // take all provided params from other and apply to self bool overwriteFrom(const self_t& other) { - return mergeBlock(selfBlockDescriptor(), other, true); + return static_cast(this)->mergeBlock(selfBlockDescriptor(), other, true); } // take all provided params that are not already provided, and apply to self bool fillFrom(const self_t& other) { - return mergeBlock(selfBlockDescriptor(), other, false); + return static_cast(this)->mergeBlock(selfBlockDescriptor(), other, false); } bool mergeBlockParam(bool source_provided, bool dest_provided, BlockDescriptor& block_data, const self_t& source, bool overwrite) @@ -1333,25 +1494,25 @@ namespace LLInitParam bool mergeBlock(BlockDescriptor& block_data, const self_t& other, bool overwrite) { mCurChoice = other.mCurChoice; - return BaseBlock::mergeBlock(selfBlockDescriptor(), other, overwrite); + return base_block_t::mergeBlock(selfBlockDescriptor(), other, overwrite); } // clear out old choice when param has changed /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { - param_handle_t changed_param_handle = BaseBlock::getHandleFromParam(&changed_param); + param_handle_t changed_param_handle = base_block_t::getHandleFromParam(&changed_param); // if we have a new choice... if (changed_param_handle != mCurChoice) { // clear provided flag on previous choice - Param* previous_choice = BaseBlock::getParamFromHandle(mCurChoice); + Param* previous_choice = base_block_t::getParamFromHandle(mCurChoice); if (previous_choice) { previous_choice->setProvided(false); } mCurChoice = changed_param_handle; } - BaseBlock::paramChanged(changed_param, user_provided); + base_block_t::paramChanged(changed_param, user_provided); } virtual const BlockDescriptor& mostDerivedBlockDescriptor() const { return selfBlockDescriptor(); } @@ -1361,7 +1522,7 @@ namespace LLInitParam ChoiceBlock() : mCurChoice(0) { - BaseBlock::init(selfBlockDescriptor(), BaseBlock::selfBlockDescriptor(), sizeof(DERIVED_BLOCK)); + BaseBlock::init(selfBlockDescriptor(), base_block_t::selfBlockDescriptor(), sizeof(DERIVED_BLOCK)); } // Alternatives are mutually exclusive wrt other Alternatives in the same block. @@ -1447,7 +1608,7 @@ namespace LLInitParam const Param* getCurrentChoice() const { - return BaseBlock::getParamFromHandle(mCurChoice); + return base_block_t::getParamFromHandle(mCurChoice); } }; @@ -1493,6 +1654,9 @@ namespace LLInitParam typedef TypedParam >::value> super_t; typedef typename super_t::value_assignment_t value_assignment_t; + using super_t::operator(); + using super_t::operator=; + explicit Optional(const char* name = "", value_assignment_t val = defaultValue()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1) { @@ -1510,7 +1674,6 @@ namespace LLInitParam super_t::set(val); return static_cast(Param::enclosingBlock()); } - using super_t::operator(); }; template > @@ -1521,6 +1684,9 @@ namespace LLInitParam typedef Mandatory self_t; typedef typename super_t::value_assignment_t value_assignment_t; + using super_t::operator(); + using super_t::operator=; + // mandatory parameters require a name to be parseable explicit Mandatory(const char* name = "", value_assignment_t val = defaultValue()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, &validate, 1, 1) @@ -1537,7 +1703,6 @@ namespace LLInitParam super_t::set(val); return static_cast(Param::enclosingBlock()); } - using super_t::operator(); static bool validate(const Param* p) { @@ -1693,14 +1858,12 @@ namespace LLInitParam ParamValue() : block_t(), - mKeyVersion(0), mValidatedVersion(-1), mValidated(false) {} ParamValue(value_assignment_t other) : block_t(other), - mKeyVersion(0), mValidatedVersion(-1), mValidated(false) { @@ -1731,11 +1894,82 @@ namespace LLInitParam return *this; } - S32 mKeyVersion; + protected: + mutable S32 mValidatedVersion; + mutable bool mValidated; // lazy validation flag + }; + + template + class ParamValue , + TypeValues, + false> + { + public: + typedef ParamValue , TypeValues, false> self_t; + typedef const T& value_assignment_t; + + ParamValue() + : mValue(), + mValidatedVersion(-1), + mValidated(false) + {} + + ParamValue(value_assignment_t other) + : mValue(other), + mValidatedVersion(-1), + mValidated(false) + {} + + void setValue(value_assignment_t val) + { + mValue.set(val); + } + + value_assignment_t getValue() const + { + return mValue.get(); + } + + T& getValue() + { + return mValue.get(); + } + + operator value_assignment_t() const + { + return mValue.get(); + } + + value_assignment_t operator()() const + { + return mValue.get(); + } + + bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool new_name) + { + return mValue.get().deserializeBlock(p, name_stack_range, new_name); + } + + void serializeBlock(Parser& p, Parser::name_stack_t& name_stack, const BaseBlock* diff_block = NULL) const + { + if (mValue.empty()) return; + + mValue.get().serializeBlock(p, name_stack, diff_block); + } + + bool inspectBlock(Parser& p, Parser::name_stack_t name_stack = Parser::name_stack_t(), S32 min_count = 0, S32 max_count = S32_MAX) const + { + if (mValue.empty()) return false; + + return mValue.get().inspectBlock(p, name_stack, min_count, max_count); + } protected: mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag + + private: + BaseBlock::Lazy mValue; }; template <> @@ -1750,14 +1984,12 @@ namespace LLInitParam typedef const LLSD& value_assignment_t; ParamValue() - : mKeyVersion(0), - mValidatedVersion(-1), + : mValidatedVersion(-1), mValidated(false) {} ParamValue(value_assignment_t other) : mValue(other), - mKeyVersion(0), mValidatedVersion(-1), mValidated(false) {} @@ -1770,7 +2002,6 @@ namespace LLInitParam operator value_assignment_t() const { return mValue; } value_assignment_t operator()() const { return mValue; } - S32 mKeyVersion; // block param interface bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool new_name); @@ -1812,7 +2043,6 @@ namespace LLInitParam CustomParamValue(const T& value = T()) : mValue(value), mValueAge(VALUE_AUTHORITATIVE), - mKeyVersion(0), mValidatedVersion(-1), mValidated(false) {} @@ -1966,8 +2196,6 @@ namespace LLInitParam return getValue(); } - S32 mKeyVersion; - protected: // use this from within updateValueFromBlock() to set the value without making it authoritative diff --git a/indra/llxuixml/llxuiparser.cpp b/indra/llxuixml/llxuiparser.cpp index 878f992178..cdf578113a 100644 --- a/indra/llxuixml/llxuiparser.cpp +++ b/indra/llxuixml/llxuiparser.cpp @@ -59,28 +59,26 @@ const char* NO_VALUE_MARKER = "no_value"; const S32 LINE_NUMBER_HERE = 0; -struct MaxOccur : public LLInitParam::ChoiceBlock +struct MaxOccursValues : public LLInitParam::TypeValuesHelper { - Alternative count; - Alternative unbounded; - - MaxOccur() - : unbounded("", "unbounded") - {} + using TypeValuesHelper::operator =; + typedef std::string name_t; + static void declareValues() + { + declare("unbounded", U32_MAX); + } }; struct Occurs : public LLInitParam::Block { - Optional minOccurs; - Optional maxOccurs; + Optional minOccurs; + Optional maxOccurs; + Multiple foo; Occurs() - : minOccurs("minOccurs"), - maxOccurs("maxOccurs") - { - minOccurs = 0; - maxOccurs.unbounded.choose(); - } + : minOccurs("minOccurs", 0), + maxOccurs("maxOccurs", U32_MAX) + {} }; @@ -103,18 +101,15 @@ namespace LLInitParam }; } -struct Name : public LLInitParam::Block -{ - Mandatory name; - - Name() - : name("name") - {} -}; +struct Element; +struct Group; +struct Choice; +struct Sequence; +struct Any; struct Attribute : public LLInitParam::Block { - Mandatory name; + Mandatory name; Mandatory type; Mandatory use; @@ -122,41 +117,170 @@ struct Attribute : public LLInitParam::Block : name("name"), type("type"), use("use") + {} +}; + +struct Any : public LLInitParam::Block +{ + Optional _namespace; + + Any() + : _namespace("namespace") + {} +}; + +struct All : public LLInitParam::Block +{ + Multiple> elements; + + All() + : elements("element") { + maxOccurs = 1; } }; -struct ComplexType : public LLInitParam::Block +struct Choice : public LLInitParam::ChoiceBlock +{ + Alternative> element; + Alternative> group; + Alternative> choice; + Alternative> sequence; + Alternative> any; + + Choice() + : element("element"), + group("group"), + choice("choice"), + sequence("sequence"), + any("any") + {} + +}; + +struct Sequence : public LLInitParam::ChoiceBlock +{ + Alternative> element; + Alternative> group; + Alternative> choice; + Alternative> sequence; + Alternative> any; +}; + +struct GroupContents : public LLInitParam::ChoiceBlock { - Multiple attribute; - //Multiple elements; - Optional mixed; + Alternative all; + Alternative choice; + Alternative sequence; + + GroupContents() + : all("all"), + choice("choice"), + sequence("sequence") + {} +}; + +struct Group : public LLInitParam::Block +{ + Optional name, + ref; + + Group() + : name("name"), + ref("ref") + {} +}; + +struct Restriction : public LLInitParam::Block +{ +}; + +struct Extension : public LLInitParam::Block +{ +}; + +struct SimpleContent : public LLInitParam::ChoiceBlock +{ + Alternative restriction; + Alternative extension; + + SimpleContent() + : restriction("restriction"), + extension("extension") + {} +}; + +struct SimpleType : public LLInitParam::Block +{ + // TODO +}; + +struct ComplexContent : public LLInitParam::Block +{ + Optional mixed; + + ComplexContent() + : mixed("mixed", true) + {} +}; + +struct ComplexTypeContents : public LLInitParam::ChoiceBlock +{ + Alternative simple_content; + Alternative complex_content; + Alternative group; + Alternative all; + Alternative choice; + Alternative sequence; + + ComplexTypeContents() + : simple_content("simpleContent"), + complex_content("complexContent"), + group("group"), + all("all"), + choice("choice"), + sequence("sequence") + {} +}; + +struct ComplexType : public LLInitParam::Block +{ + Optional name; + Optional mixed; + + Multiple attribute; + Multiple> elements; ComplexType() - : attribute("xs:attribute"), - //elements("xs:element"), + : name("name"), + attribute("xs:attribute"), + elements("xs:element"), mixed("mixed") { - mixed = true; } }; -struct Element : public LLInitParam::Block +struct ElementContents : public LLInitParam::ChoiceBlock { - Mandatory complexType; - Mandatory name; + Alternative simpleType; + Alternative complexType; - Element() - : complexType("xs:complexType") + ElementContents() + : simpleType("simpleType"), + complexType("complexType") {} }; -struct Elements : public LLInitParam::Block +struct Element : public LLInitParam::Block { - Multiple elements; + Optional name, + ref, + type; - Elements() - : elements("xs:element") + Element() + : name("xs:name"), + ref("xs:ref"), + type("xs:type") {} }; @@ -164,28 +288,32 @@ struct Schema : public LLInitParam::Block { private: Mandatory targetNamespace, - xmlns; + xmlns, + xs; public: Optional attributeFormDefault, - elementFormDefault, - xs; + elementFormDefault; - Optional elements; + Mandatory root_element; void setNameSpace(const std::string& ns) {targetNamespace = ns; xmlns = ns;} - Schema() + Schema(const std::string& ns = LLStringUtil::null) : attributeFormDefault("attributeFormDefault"), elementFormDefault("elementFormDefault"), xs("xmlns:xs"), targetNamespace("targetNamespace"), xmlns("xmlns"), - elements("xs:choice") + root_element("xs:element") { attributeFormDefault = "unqualified"; elementFormDefault = "qualified"; xs = "http://www.w3.org/2001/XMLSchema"; + if (!ns.empty()) + { + setNameSpace(ns); + }; } }; @@ -214,22 +342,30 @@ LLXSDWriter::LLXSDWriter() void LLXSDWriter::writeXSD(const std::string& type_name, LLXMLNodePtr node, const LLInitParam::BaseBlock& block, const std::string& xml_namespace) { + Schema schema(xml_namespace); + + schema.root_element.name = type_name; + Choice& choice = schema.root_element.complexType.choice; + + choice.minOccurs = 0; + choice.maxOccurs = "unbounded"; + mSchemaNode = node; - node->setName("xs:schema"); - node->createChild("attributeFormDefault", true)->setStringValue("unqualified"); - node->createChild("elementFormDefault", true)->setStringValue("qualified"); - node->createChild("targetNamespace", true)->setStringValue(xml_namespace); - node->createChild("xmlns:xs", true)->setStringValue("http://www.w3.org/2001/XMLSchema"); - node->createChild("xmlns", true)->setStringValue(xml_namespace); - - node = node->createChild("xs:complexType", false); - node->createChild("name", true)->setStringValue(type_name); - node->createChild("mixed", true)->setStringValue("true"); - - mAttributeNode = node; - mElementNode = node->createChild("xs:choice", false); - mElementNode->createChild("minOccurs", true)->setStringValue("0"); - mElementNode->createChild("maxOccurs", true)->setStringValue("unbounded"); + //node->setName("xs:schema"); + //node->createChild("attributeFormDefault", true)->setStringValue("unqualified"); + //node->createChild("elementFormDefault", true)->setStringValue("qualified"); + //node->createChild("targetNamespace", true)->setStringValue(xml_namespace); + //node->createChild("xmlns:xs", true)->setStringValue("http://www.w3.org/2001/XMLSchema"); + //node->createChild("xmlns", true)->setStringValue(xml_namespace); + + //node = node->createChild("xs:complexType", false); + //node->createChild("name", true)->setStringValue(type_name); + //node->createChild("mixed", true)->setStringValue("true"); + + //mAttributeNode = node; + //mElementNode = node->createChild("xs:choice", false); + //mElementNode->createChild("minOccurs", true)->setStringValue("0"); + //mElementNode->createChild("maxOccurs", true)->setStringValue("unbounded"); block.inspectBlock(*this); // duplicate element choices -- cgit v1.2.3 From 0c9d8d917a4281e2dea7fa2044e86735caca2aa9 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Thu, 10 Nov 2011 16:02:57 -0800 Subject: fixed build fixed handle downcast not initiating handle --- indra/llxuixml/llinitparam.h | 2 ++ 1 file changed, 2 insertions(+) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 169a724bca..f5f6876736 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -671,6 +671,7 @@ namespace LLInitParam self_t& operator =(const self_t& other) { mValue = other.mValue; + return *this; } private: @@ -741,6 +742,7 @@ namespace LLInitParam self_t& operator =(const self_t& other) { *(static_cast(this)) = other; + return *this; } protected: mutable S32 mValidatedVersion; -- cgit v1.2.3 From 267e75d8dc36386070ddb3ecebb31a7bbadd6d03 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Fri, 11 Nov 2011 11:17:44 -0800 Subject: support for assignment of named values to params --- indra/llxuixml/llinitparam.cpp | 1 + indra/llxuixml/llinitparam.h | 55 +++++++++++++++++++++--------------------- 2 files changed, 28 insertions(+), 28 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.cpp b/indra/llxuixml/llinitparam.cpp index 482064ed7b..8880072f06 100644 --- a/indra/llxuixml/llinitparam.cpp +++ b/indra/llxuixml/llinitparam.cpp @@ -478,6 +478,7 @@ namespace LLInitParam if (merge_func) { Param* paramp = getParamFromHandle((*it)->mParamHandle); + llassert(paramp->mEnclosingBlockOffset == (*it)->mParamHandle); some_param_changed |= merge_func(*paramp, *other_paramp, overwrite); } } diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index f5f6876736..ec14bc2fdc 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -671,10 +671,11 @@ namespace LLInitParam self_t& operator =(const self_t& other) { mValue = other.mValue; + static_cast(*this) = other; return *this; } - private: + protected: T mValue; }; @@ -741,7 +742,10 @@ namespace LLInitParam self_t& operator =(const self_t& other) { - *(static_cast(this)) = other; + static_cast(*this) = other; + static_cast(*this) = other; + mValidatedVersion = other.mValidatedVersion; + mValidated = other.mValidated; return *this; } protected: @@ -875,24 +879,17 @@ namespace LLInitParam self_t& operator =(typename const name_value_lookup_t::name_t& name) { - if (name_value_lookup_t::getValueFromName(name, getValue())) - { - setValueName(name); - setProvided(); - } - - return *this; + return static_cast(param_value_t::operator =(name)); } void set(value_assignment_t val, bool flag_as_provided = true) { - setValue(val); param_value_t::clearValueName(); + setValue(val); setProvided(flag_as_provided); } protected: - static bool mergeWith(Param& dst, const Param& src, bool overwrite) { const self_t& src_typed_param = static_cast(src); @@ -1026,17 +1023,6 @@ namespace LLInitParam setProvided(flag_as_provided); } - self_t& operator =(typename const name_value_lookup_t::name_t& name) - { - if (name_value_lookup_t::getValueFromName(name, getValue())) - { - setValueName(name); - setProvided(); - } - - return *this; - } - // propagate changed status up to enclosing block /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { @@ -1239,6 +1225,12 @@ namespace LLInitParam } protected: + self_t& operator=(const self_t& other) + { + mValues = other.mValues; + return *this; + } + static bool mergeWith(Param& dst, const Param& src, bool overwrite) { const self_t& src_typed_param = static_cast(src); @@ -1432,6 +1424,11 @@ namespace LLInitParam } protected: + self_t& operator=(const self_t& other) + { + mValues = other.mValues; + return *this; + } static bool mergeWith(Param& dst, const Param& src, bool overwrite) { @@ -1540,6 +1537,8 @@ namespace LLInitParam typedef TypedParam >::value> super_t; typedef typename super_t::value_assignment_t value_assignment_t; + using super_t::param_value_t::operator =; + explicit Alternative(const char* name = "", value_assignment_t val = defaultValue()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1), mOriginalValue(val) @@ -1565,7 +1564,7 @@ namespace LLInitParam super_t::set(val); } - void operator=(value_assignment_t val) + void operator =(value_assignment_t val) { super_t::set(val); } @@ -1657,7 +1656,7 @@ namespace LLInitParam typedef typename super_t::value_assignment_t value_assignment_t; using super_t::operator(); - using super_t::operator=; + using super_t::param_value_t::operator =; explicit Optional(const char* name = "", value_assignment_t val = defaultValue()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1) @@ -1665,7 +1664,7 @@ namespace LLInitParam //#pragma message("Parsing LLInitParam::Block::Optional") } - Optional& operator=(value_assignment_t val) + Optional& operator =(value_assignment_t val) { set(val); return *this; @@ -1687,14 +1686,14 @@ namespace LLInitParam typedef typename super_t::value_assignment_t value_assignment_t; using super_t::operator(); - using super_t::operator=; + using super_t::param_value_t::operator =; // mandatory parameters require a name to be parseable explicit Mandatory(const char* name = "", value_assignment_t val = defaultValue()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, &validate, 1, 1) {} - Mandatory& operator=(value_assignment_t val) + Mandatory& operator =(value_assignment_t val) { set(val); return *this; @@ -1729,7 +1728,7 @@ namespace LLInitParam : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, container_t(), &validate, RANGE::minCount, RANGE::maxCount) {} - Multiple& operator=(value_assignment_t val) + Multiple& operator =(value_assignment_t val) { set(val); return *this; -- cgit v1.2.3 From 2ee4bae1a39814467e4bd361211f7836266af880 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Wed, 16 Nov 2011 12:28:10 -0800 Subject: support for assignment of named values to params, works with string-typed params as well as () operator --- indra/llxuixml/llinitparam.h | 93 +++++++++++++++++++++++++++++++++++------- indra/llxuixml/llxuiparser.cpp | 4 +- 2 files changed, 80 insertions(+), 17 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index ec14bc2fdc..575e8231bd 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -572,7 +572,7 @@ namespace LLInitParam static bool equals(const BaseBlock::Lazy& a, const BaseBlock::Lazy& b) { return !a.empty() || !b.empty(); } }; - class Param + class Param { public: void setProvided(bool is_provided = true) @@ -580,6 +580,12 @@ namespace LLInitParam mIsProvided = is_provided; enclosingBlock().paramChanged(*this, is_provided); } + + Param& operator =(const Param& other) + { + setProvided(other.mIsProvided); + return *this; + } protected: bool anyProvided() const { return mIsProvided; } @@ -671,7 +677,7 @@ namespace LLInitParam self_t& operator =(const self_t& other) { mValue = other.mValue; - static_cast(*this) = other; + NAME_VALUE_LOOKUP::operator =(other); return *this; } @@ -742,8 +748,8 @@ namespace LLInitParam self_t& operator =(const self_t& other) { - static_cast(*this) = other; - static_cast(*this) = other; + T::operator = (other); + NAME_VALUE_LOOKUP::operator =(other); mValidatedVersion = other.mValidatedVersion; mValidated = other.mValidated; return *this; @@ -753,6 +759,54 @@ namespace LLInitParam mutable bool mValidated; // lazy validation flag }; + template + class ParamValue + : public NAME_VALUE_LOOKUP + { + public: + typedef const std::string& value_assignment_t; + typedef ParamValue self_t; + + ParamValue(): mValue() {} + ParamValue(value_assignment_t other) : mValue(other) {} + + void setValue(value_assignment_t val) + { + if (NAME_VALUE_LOOKUP::getValueFromName(val, mValue)) + { + setValueName(val); + } + else + { + mValue = val; + } + } + + value_assignment_t getValue() const + { + return mValue; + } + + std::string& getValue() + { + return mValue; + } + + operator value_assignment_t() const + { + return mValue; + } + + value_assignment_t operator()() const + { + return mValue; + } + + protected: + std::string mValue; + }; + + template > struct ParamIterator { @@ -776,6 +830,8 @@ namespace LLInitParam typedef NAME_VALUE_LOOKUP name_value_lookup_t; typedef ParamValue param_value_t; + using param_value_t::operator(); + TypedParam(BlockDescriptor& block_descriptor, const char* name, value_assignment_t value, ParamDescriptor::validation_func_t validate_func, S32 min_count, S32 max_count) : Param(block_descriptor.mCurrentBlockPtr) { @@ -877,11 +933,6 @@ namespace LLInitParam } } - self_t& operator =(typename const name_value_lookup_t::name_t& name) - { - return static_cast(param_value_t::operator =(name)); - } - void set(value_assignment_t val, bool flag_as_provided = true) { param_value_t::clearValueName(); @@ -889,6 +940,11 @@ namespace LLInitParam setProvided(flag_as_provided); } + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) + { + return static_cast(param_value_t::operator =(name)); + } + protected: static bool mergeWith(Param& dst, const Param& src, bool overwrite) { @@ -919,6 +975,8 @@ namespace LLInitParam typedef NAME_VALUE_LOOKUP name_value_lookup_t; typedef ParamValue param_value_t; + using param_value_t::operator(); + TypedParam(BlockDescriptor& block_descriptor, const char* name, value_assignment_t value, ParamDescriptor::validation_func_t validate_func, S32 min_count, S32 max_count) : Param(block_descriptor.mCurrentBlockPtr), param_value_t(value) @@ -1023,6 +1081,11 @@ namespace LLInitParam setProvided(flag_as_provided); } + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) + { + return static_cast(param_value_t::operator =(name)); + } + // propagate changed status up to enclosing block /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { @@ -1189,7 +1252,9 @@ namespace LLInitParam void add(const value_t& item) { - mValues.push_back(param_value_t(item)); + param_value_t param_value; + param_value.setValue(item); + mValues.push_back(param_value); setProvided(); } @@ -1537,7 +1602,7 @@ namespace LLInitParam typedef TypedParam >::value> super_t; typedef typename super_t::value_assignment_t value_assignment_t; - using super_t::param_value_t::operator =; + using super_t::operator =; explicit Alternative(const char* name = "", value_assignment_t val = defaultValue()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1), @@ -1656,8 +1721,8 @@ namespace LLInitParam typedef typename super_t::value_assignment_t value_assignment_t; using super_t::operator(); - using super_t::param_value_t::operator =; - + using super_t::operator =; + explicit Optional(const char* name = "", value_assignment_t val = defaultValue()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1) { @@ -1686,7 +1751,7 @@ namespace LLInitParam typedef typename super_t::value_assignment_t value_assignment_t; using super_t::operator(); - using super_t::param_value_t::operator =; + using super_t::operator =; // mandatory parameters require a name to be parseable explicit Mandatory(const char* name = "", value_assignment_t val = defaultValue()) diff --git a/indra/llxuixml/llxuiparser.cpp b/indra/llxuixml/llxuiparser.cpp index cdf578113a..90c2671242 100644 --- a/indra/llxuixml/llxuiparser.cpp +++ b/indra/llxuixml/llxuiparser.cpp @@ -61,8 +61,6 @@ const S32 LINE_NUMBER_HERE = 0; struct MaxOccursValues : public LLInitParam::TypeValuesHelper { - using TypeValuesHelper::operator =; - typedef std::string name_t; static void declareValues() { declare("unbounded", U32_MAX); @@ -73,11 +71,11 @@ struct Occurs : public LLInitParam::Block { Optional minOccurs; Optional maxOccurs; - Multiple foo; Occurs() : minOccurs("minOccurs", 0), maxOccurs("maxOccurs", U32_MAX) + {} }; -- cgit v1.2.3 From 4924306db50bdf0c621d19455c0d07fbf74859f8 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Fri, 18 Nov 2011 09:39:10 -0800 Subject: fix for notification buttons not being read --- indra/llxuixml/llinitparam.h | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 575e8231bd..2edb9b98c7 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -945,6 +945,12 @@ namespace LLInitParam return static_cast(param_value_t::operator =(name)); } + self_t& operator =(value_assignment_t val) + { + set(val); + return *this; + } + protected: static bool mergeWith(Param& dst, const Param& src, bool overwrite) { @@ -1086,6 +1092,12 @@ namespace LLInitParam return static_cast(param_value_t::operator =(name)); } + self_t& operator =(value_assignment_t val) + { + set(val); + return *this; + } + // propagate changed status up to enclosing block /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { @@ -1290,12 +1302,6 @@ namespace LLInitParam } protected: - self_t& operator=(const self_t& other) - { - mValues = other.mValues; - return *this; - } - static bool mergeWith(Param& dst, const Param& src, bool overwrite) { const self_t& src_typed_param = static_cast(src); @@ -1489,11 +1495,6 @@ namespace LLInitParam } protected: - self_t& operator=(const self_t& other) - { - mValues = other.mValues; - return *this; - } static bool mergeWith(Param& dst, const Param& src, bool overwrite) { -- cgit v1.2.3 From 0bea8f2a9738502c8bc5482522de3b7ea49f989d Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Sat, 19 Nov 2011 07:48:24 -0800 Subject: fix for notification dialog buttons not working --- indra/llxuixml/llinitparam.h | 39 ++++++++++++++------------------------- 1 file changed, 14 insertions(+), 25 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 2edb9b98c7..5ed3337c45 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -583,7 +583,8 @@ namespace LLInitParam Param& operator =(const Param& other) { - setProvided(other.mIsProvided); + mIsProvided = other.mIsProvided; + // don't change mEnclosingblockoffset return *this; } protected: @@ -674,13 +675,6 @@ namespace LLInitParam return *this; } - self_t& operator =(const self_t& other) - { - mValue = other.mValue; - NAME_VALUE_LOOKUP::operator =(other); - return *this; - } - protected: T mValue; }; @@ -746,14 +740,6 @@ namespace LLInitParam return *this; } - self_t& operator =(const self_t& other) - { - T::operator = (other); - NAME_VALUE_LOOKUP::operator =(other); - mValidatedVersion = other.mValidatedVersion; - mValidated = other.mValidated; - return *this; - } protected: mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag @@ -945,13 +931,15 @@ namespace LLInitParam return static_cast(param_value_t::operator =(name)); } - self_t& operator =(value_assignment_t val) + protected: + + self_t& operator =(const self_t& other) { - set(val); + param_value_t::operator =(other); + Param::operator =(other); return *this; } - protected: static bool mergeWith(Param& dst, const Param& src, bool overwrite) { const self_t& src_typed_param = static_cast(src); @@ -1092,12 +1080,6 @@ namespace LLInitParam return static_cast(param_value_t::operator =(name)); } - self_t& operator =(value_assignment_t val) - { - set(val); - return *this; - } - // propagate changed status up to enclosing block /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { @@ -1117,6 +1099,13 @@ namespace LLInitParam protected: + self_t& operator =(const self_t& other) + { + param_value_t::operator =(other); + Param::operator =(other); + return *this; + } + static bool mergeWith(Param& dst, const Param& src, bool overwrite) { const self_t& src_typed_param = static_cast(src); -- cgit v1.2.3 From 2851cd519338ef4a1fde15da8d4015ab4380d6cb Mon Sep 17 00:00:00 2001 From: Xiaohong Bao Date: Mon, 28 Nov 2011 11:33:49 -0700 Subject: a try fix for sh-2651: [crashhunters] Crash after google translate failure and sh-2658: crash in LLPluginMessage::parse --- indra/llxuixml/llxuiparser.cpp | 1 + 1 file changed, 1 insertion(+) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llxuiparser.cpp b/indra/llxuixml/llxuiparser.cpp index 878f992178..5a525f84a8 100644 --- a/indra/llxuixml/llxuiparser.cpp +++ b/indra/llxuixml/llxuiparser.cpp @@ -1247,6 +1247,7 @@ bool LLSimpleXUIParser::readXUI(const std::string& filename, LLInitParam::BaseBl if( !file.isOpen() ) { LL_WARNS("ReadXUI") << "Unable to open file " << filename << LL_ENDL; + XML_ParserFree( mParser ); return false; } -- cgit v1.2.3 From 700277e00aa83506808f2128705143d7ae4937bd Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Mon, 28 Nov 2011 22:30:12 -0800 Subject: removed unneeded changeversion tracking in param blocks in favor of a simpler dirty bit --- indra/llxuixml/llinitparam.cpp | 20 +----------- indra/llxuixml/llinitparam.h | 74 ++++++++++++++++++++---------------------- 2 files changed, 36 insertions(+), 58 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.cpp b/indra/llxuixml/llinitparam.cpp index 8880072f06..db72aa19b9 100644 --- a/indra/llxuixml/llinitparam.cpp +++ b/indra/llxuixml/llinitparam.cpp @@ -40,7 +40,7 @@ namespace LLInitParam { const U8* my_addr = reinterpret_cast(this); const U8* block_addr = reinterpret_cast(enclosing_block); - mEnclosingBlockOffset = 0x7FFFffff & ((U32)(my_addr - block_addr)); + mEnclosingBlockOffset = 0x7FFFffff & (U32)(my_addr - block_addr); } // @@ -118,16 +118,6 @@ namespace LLInitParam mCurrentBlockPtr(NULL) {} - // - // BaseBlock - // - BaseBlock::BaseBlock() - : mChangeVersion(0) - {} - - BaseBlock::~BaseBlock() - {} - // called by each derived class in least to most derived order void BaseBlock::init(BlockDescriptor& descriptor, BlockDescriptor& base_descriptor, size_t block_size) { @@ -427,14 +417,6 @@ namespace LLInitParam } } - void BaseBlock::paramChanged(const Param& changed_param, bool user_provided) - { - if (user_provided) - { - mChangeVersion++; - } - } - const std::string& BaseBlock::getParamName(const BlockDescriptor& block_data, const Param* paramp) const { param_handle_t handle = getHandleFromParam(paramp); diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 5ed3337c45..80b6504c4f 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -491,8 +491,7 @@ namespace LLInitParam LOG_CLASS(BaseBlock); friend class Param; - BaseBlock(); - virtual ~BaseBlock(); + virtual ~BaseBlock() {} bool submitValue(Parser::name_stack_t& name_stack, Parser& p, bool silent=false); param_handle_t getHandleFromParam(const Param* param) const; @@ -515,9 +514,7 @@ namespace LLInitParam void addSynonym(Param& param, const std::string& synonym); // Blocks can override this to do custom tracking of changes - virtual void paramChanged(const Param& changed_param, bool user_provided); - - S32 getLastChangeVersion() const { return mChangeVersion; } + virtual void paramChanged(const Param& changed_param, bool user_provided) {} bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool new_name); void serializeBlock(Parser& p, Parser::name_stack_t& name_stack, const BaseBlock* diff_block = NULL) const; @@ -553,9 +550,6 @@ namespace LLInitParam // take all provided params from other and apply to self bool mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite); - // can be updated in getters - mutable S32 mChangeVersion; - static BlockDescriptor& selfBlockDescriptor() { static BlockDescriptor sBlockDescriptor; @@ -604,7 +598,7 @@ namespace LLInitParam } private: - friend class BaseBlock; + friend BaseBlock; U32 mEnclosingBlockOffset:31; U32 mIsProvided:1; @@ -617,12 +611,22 @@ namespace LLInitParam struct IsBlock { static const bool value = false; + struct EmptyBase {}; + typedef EmptyBase base_class_t; }; template struct IsBlock { static const bool value = true; + typedef BaseBlock base_class_t; + }; + + template + struct IsBlock, typename T::baseblock_base_class_t > + { + static const bool value = true; + typedef BaseBlock base_class_t; }; template::value> @@ -630,6 +634,7 @@ namespace LLInitParam { public: typedef const T& value_assignment_t; + typedef T value_t; typedef ParamValue self_t; ParamValue(): mValue() {} @@ -686,17 +691,16 @@ namespace LLInitParam { public: typedef const T& value_assignment_t; + typedef T value_t; typedef ParamValue self_t; ParamValue() : T(), - mValidatedVersion(-1), mValidated(false) {} ParamValue(value_assignment_t other) : T(other), - mValidatedVersion(-1), mValidated(false) {} @@ -741,7 +745,6 @@ namespace LLInitParam } protected: - mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag }; @@ -751,6 +754,7 @@ namespace LLInitParam { public: typedef const std::string& value_assignment_t; + typedef std::string value_t; typedef ParamValue self_t; ParamValue(): mValue() {} @@ -811,10 +815,10 @@ namespace LLInitParam public ParamValue { public: - typedef const T& value_assignment_t; typedef TypedParam self_t; - typedef NAME_VALUE_LOOKUP name_value_lookup_t; typedef ParamValue param_value_t; + typedef param_value_t::value_assignment_t value_assignment_t; + typedef NAME_VALUE_LOOKUP name_value_lookup_t; using param_value_t::operator(); @@ -962,12 +966,10 @@ namespace LLInitParam public ParamValue { public: - typedef const T value_const_t; - typedef T value_t; - typedef value_const_t& value_assignment_t; + typedef ParamValue param_value_t; + typedef typename param_value_t::value_assignment_t value_assignment_t; typedef TypedParam self_t; typedef NAME_VALUE_LOOKUP name_value_lookup_t; - typedef ParamValue param_value_t; using param_value_t::operator(); @@ -1055,11 +1057,10 @@ namespace LLInitParam bool isProvided() const { // only validate block when it hasn't already passed validation with current data - if (Param::anyProvided() && param_value_t::mValidatedVersion < param_value_t::getLastChangeVersion()) + if (Param::anyProvided() && !param_value_t::mValidated) { // a sub-block is "provided" when it has been filled in enough to be valid param_value_t::mValidated = param_value_t::validateBlock(false); - param_value_t::mValidatedVersion = param_value_t::getLastChangeVersion(); } return Param::anyProvided() && param_value_t::mValidated; } @@ -1069,9 +1070,9 @@ namespace LLInitParam { setValue(val); param_value_t::clearValueName(); - // force revalidation of block by clearing known provided version + // force revalidation of block // next call to isProvided() will update provision status based on validity - param_value_t::mValidatedVersion = -1; + param_value_t::mValidated = false; setProvided(flag_as_provided); } @@ -1088,6 +1089,7 @@ namespace LLInitParam { // a child param has been explicitly changed // so *some* aspect of this block is now provided + param_value_t::mValidated = false; setProvided(); param_value_t::clearValueName(); } @@ -1135,7 +1137,7 @@ namespace LLInitParam typedef typename std::vector container_t; typedef const container_t& value_assignment_t; - typedef VALUE_TYPE value_t; + typedef typename param_value_t::value_t value_t; typedef NAME_VALUE_LOOKUP name_value_lookup_t; TypedParam(BlockDescriptor& block_descriptor, const char* name, value_assignment_t value, ParamDescriptor::validation_func_t validate_func, S32 min_count, S32 max_count) @@ -1327,7 +1329,7 @@ namespace LLInitParam typedef ParamValue param_value_t; typedef typename std::vector container_t; typedef const container_t& value_assignment_t; - typedef VALUE_TYPE value_t; + typedef typename param_value_t::value_t value_t; typedef NAME_VALUE_LOOKUP name_value_lookup_t; TypedParam(BlockDescriptor& block_descriptor, const char* name, value_assignment_t value, ParamDescriptor::validation_func_t validate_func, S32 min_count, S32 max_count) @@ -1911,16 +1913,15 @@ namespace LLInitParam public: typedef BatchBlock block_t; typedef const BatchBlock& value_assignment_t; + typedef block_t value_t; ParamValue() : block_t(), - mValidatedVersion(-1), mValidated(false) {} ParamValue(value_assignment_t other) : block_t(other), - mValidatedVersion(-1), mValidated(false) { } @@ -1951,28 +1952,27 @@ namespace LLInitParam } protected: - mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag }; - template + template class ParamValue , TypeValues, - false> + IS_BLOCK> + : public IsBlock::base_class_t { public: typedef ParamValue , TypeValues, false> self_t; typedef const T& value_assignment_t; + typedef T value_t; ParamValue() : mValue(), - mValidatedVersion(-1), mValidated(false) {} ParamValue(value_assignment_t other) : mValue(other), - mValidatedVersion(-1), mValidated(false) {} @@ -2021,7 +2021,6 @@ namespace LLInitParam } protected: - mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag private: @@ -2040,13 +2039,11 @@ namespace LLInitParam typedef const LLSD& value_assignment_t; ParamValue() - : mValidatedVersion(-1), - mValidated(false) + : mValidated(false) {} ParamValue(value_assignment_t other) : mValue(other), - mValidatedVersion(-1), mValidated(false) {} @@ -2069,7 +2066,6 @@ namespace LLInitParam } protected: - mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag private: @@ -2093,13 +2089,14 @@ namespace LLInitParam typedef ParamValue > derived_t; typedef CustomParamValue self_t; - typedef Block block_t; + typedef Block block_t; typedef const T& value_assignment_t; + typedef T value_t; + CustomParamValue(const T& value = T()) : mValue(value), mValueAge(VALUE_AUTHORITATIVE), - mValidatedVersion(-1), mValidated(false) {} @@ -2285,7 +2282,6 @@ namespace LLInitParam return block_t::mergeBlock(block_data, source, overwrite); } - mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag private: -- cgit v1.2.3 From 0c54cf51db0c1a6e0b2ac91d69b2646570b168eb Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Wed, 30 Nov 2011 18:32:28 -0800 Subject: gcc fix attempt --- indra/llxuixml/llinitparam.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 80b6504c4f..7927f84cba 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -598,7 +598,7 @@ namespace LLInitParam } private: - friend BaseBlock; + friend class BaseBlock; U32 mEnclosingBlockOffset:31; U32 mIsProvided:1; @@ -736,7 +736,7 @@ namespace LLInitParam self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) { - if (NAME_VALUE_LOOKUP::getValueFromName(name, mValue)) + if (NAME_VALUE_LOOKUP::getValueFromName(name, *this)) { setValueName(name); } @@ -817,7 +817,7 @@ namespace LLInitParam public: typedef TypedParam self_t; typedef ParamValue param_value_t; - typedef param_value_t::value_assignment_t value_assignment_t; + typedef typename param_value_t::value_assignment_t value_assignment_t; typedef NAME_VALUE_LOOKUP name_value_lookup_t; using param_value_t::operator(); @@ -1261,7 +1261,7 @@ namespace LLInitParam setProvided(); } - void add(typename const name_value_lookup_t::name_t& name) + void add(const typename name_value_lookup_t::name_t& name) { value_t value; @@ -1447,7 +1447,7 @@ namespace LLInitParam setProvided(); } - void add(typename const name_value_lookup_t::name_t& name) + void add(const typename name_value_lookup_t::name_t& name) { value_t value; -- cgit v1.2.3 From 770538f992a42cdda091f93e8b318e35372aaad2 Mon Sep 17 00:00:00 2001 From: Leslie Linden Date: Thu, 1 Dec 2011 10:42:15 -0800 Subject: Build fixes for mac, hopefully Linux too --- indra/llxuixml/llinitparam.h | 2 +- indra/llxuixml/llxuiparser.cpp | 24 ++++++++++++------------ 2 files changed, 13 insertions(+), 13 deletions(-) (limited to 'indra/llxuixml') diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 7927f84cba..ab20957760 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -764,7 +764,7 @@ namespace LLInitParam { if (NAME_VALUE_LOOKUP::getValueFromName(val, mValue)) { - setValueName(val); + NAME_VALUE_LOOKUP::setValueName(val); } else { diff --git a/indra/llxuixml/llxuiparser.cpp b/indra/llxuixml/llxuiparser.cpp index 90c2671242..58654dcc21 100644 --- a/indra/llxuixml/llxuiparser.cpp +++ b/indra/llxuixml/llxuiparser.cpp @@ -129,7 +129,7 @@ struct Any : public LLInitParam::Block struct All : public LLInitParam::Block { - Multiple> elements; + Multiple< Lazy > elements; All() : elements("element") @@ -140,11 +140,11 @@ struct All : public LLInitParam::Block struct Choice : public LLInitParam::ChoiceBlock { - Alternative> element; - Alternative> group; - Alternative> choice; - Alternative> sequence; - Alternative> any; + Alternative< Lazy > element; + Alternative< Lazy > group; + Alternative< Lazy > choice; + Alternative< Lazy > sequence; + Alternative< Lazy > any; Choice() : element("element"), @@ -158,11 +158,11 @@ struct Choice : public LLInitParam::ChoiceBlock struct Sequence : public LLInitParam::ChoiceBlock { - Alternative> element; - Alternative> group; - Alternative> choice; - Alternative> sequence; - Alternative> any; + Alternative< Lazy > element; + Alternative< Lazy > group; + Alternative< Lazy > choice; + Alternative< Lazy > sequence; + Alternative< Lazy > any; }; struct GroupContents : public LLInitParam::ChoiceBlock @@ -247,7 +247,7 @@ struct ComplexType : public LLInitParam::Block Optional mixed; Multiple attribute; - Multiple> elements; + Multiple< Lazy > elements; ComplexType() : name("name"), -- cgit v1.2.3