diff options
author | Todd Stinson <stinson@lindenlab.com> | 2011-12-13 11:15:18 -0800 |
---|---|---|
committer | Todd Stinson <stinson@lindenlab.com> | 2011-12-13 11:15:18 -0800 |
commit | 9d1db4f19ae7ca044e47d0fe4e605e14882351c5 (patch) | |
tree | 2d499d53b60b2486f1e6666f8b9fe2063f984d22 /indra/llxuixml/llinitparam.h | |
parent | 817c97c2f836948f210599a6f67e36a411b22c21 (diff) | |
parent | dbc91a7fac9513bdd879c5c2dc82208e08eaad2d (diff) |
Pull and merge from https://bitbucket.org/lindenlab/viewer-development.
Diffstat (limited to 'indra/llxuixml/llinitparam.h')
-rw-r--r-- | indra/llxuixml/llinitparam.h | 556 |
1 files changed, 418 insertions, 138 deletions
diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 183472450d..ab20957760 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<typename T> struct ParamCompare<T, true> @@ -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 <typename T> class TypeValues { + private: + struct Inaccessable{}; public: typedef std::map<std::string, T> 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<std::string, T> 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<const U8*>(this); - // get address of enclosing BLOCK class using stored offset to enclosing BaseBlock class - return *const_cast<BaseBlock*> - (reinterpret_cast<const BaseBlock*> - (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<typename T> + 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<T>& operator = (const Lazy<T>& 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 { @@ -436,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; @@ -460,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; @@ -498,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; @@ -511,18 +560,73 @@ namespace LLInitParam const std::string& getParamName(const BlockDescriptor& block_data, const Param* paramp) const; }; + template<typename T> + struct ParamCompare<BaseBlock::Lazy<T>, false > + { + static bool equals(const BaseBlock::Lazy<T>& a, const BaseBlock::Lazy<T>& b) { return !a.empty() || !b.empty(); } + }; + + class Param + { + public: + void setProvided(bool is_provided = true) + { + mIsProvided = is_provided; + enclosingBlock().paramChanged(*this, is_provided); + } + + Param& operator =(const Param& other) + { + mIsProvided = other.mIsProvided; + // don't change mEnclosingblockoffset + return *this; + } + 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<const U8*>(this); + // get address of enclosing BLOCK class using stored offset to enclosing BaseBlock class + return *const_cast<BaseBlock*> + (reinterpret_cast<const BaseBlock*> + (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<typename T, typename Void = void> struct IsBlock { static const bool value = false; + struct EmptyBase {}; + typedef EmptyBase base_class_t; }; template<typename T> struct IsBlock<T, typename T::baseblock_base_class_t> { static const bool value = true; + typedef BaseBlock base_class_t; + }; + + template<typename T> + struct IsBlock<BaseBlock::Lazy<T>, typename T::baseblock_base_class_t > + { + static const bool value = true; + typedef BaseBlock base_class_t; }; template<typename T, typename NAME_VALUE_LOOKUP, bool VALUE_IS_BLOCK = IsBlock<T>::value> @@ -530,6 +634,8 @@ namespace LLInitParam { public: typedef const T& value_assignment_t; + typedef T value_t; + typedef ParamValue<T, NAME_VALUE_LOOKUP, VALUE_IS_BLOCK> self_t; ParamValue(): mValue() {} ParamValue(value_assignment_t other) : mValue(other) {} @@ -559,8 +665,22 @@ namespace LLInitParam return mValue; } + void operator ()(const typename NAME_VALUE_LOOKUP::name_t& name) + { + *this = name; + } - private: + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) + { + if (NAME_VALUE_LOOKUP::getValueFromName(name, mValue)) + { + setValueName(name); + } + + return *this; + } + + protected: T mValue; }; @@ -571,18 +691,16 @@ namespace LLInitParam { public: typedef const T& value_assignment_t; + typedef T value_t; + typedef ParamValue<T, NAME_VALUE_LOOKUP, true> self_t; ParamValue() : T(), - mKeyVersion(0), - mValidatedVersion(-1), mValidated(false) {} ParamValue(value_assignment_t other) : T(other), - mKeyVersion(0), - mValidatedVersion(-1), mValidated(false) {} @@ -611,13 +729,74 @@ 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, *this)) + { + setValueName(name); + } + + return *this; + } protected: - mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag }; + template<typename NAME_VALUE_LOOKUP> + class ParamValue<std::string, NAME_VALUE_LOOKUP, false> + : public NAME_VALUE_LOOKUP + { + public: + typedef const std::string& value_assignment_t; + typedef std::string value_t; + typedef ParamValue<std::string, NAME_VALUE_LOOKUP, false> self_t; + + ParamValue(): mValue() {} + ParamValue(value_assignment_t other) : mValue(other) {} + + void setValue(value_assignment_t val) + { + if (NAME_VALUE_LOOKUP::getValueFromName(val, mValue)) + { + NAME_VALUE_LOOKUP::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<typename T, typename NAME_VALUE_LOOKUP = TypeValues<T> > struct ParamIterator { @@ -636,10 +815,12 @@ namespace LLInitParam public ParamValue<T, NAME_VALUE_LOOKUP> { public: - typedef const T& value_assignment_t; typedef TypedParam<T, NAME_VALUE_LOOKUP, HAS_MULTIPLE_VALUES, VALUE_IS_BLOCK> self_t; - typedef NAME_VALUE_LOOKUP name_value_lookup_t; typedef ParamValue<T, NAME_VALUE_LOOKUP> param_value_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(); 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) @@ -671,8 +852,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 +867,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; } @@ -746,14 +925,25 @@ namespace LLInitParam void set(value_assignment_t val, bool flag_as_provided = true) { - setValue(val); param_value_t::clearValueName(); + setValue(val); setProvided(flag_as_provided); - Param::enclosingBlock().paramChanged(*this, flag_as_provided); + } + + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) + { + return static_cast<self_t&>(param_value_t::operator =(name)); } 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<const self_t&>(src); @@ -776,12 +966,12 @@ namespace LLInitParam public ParamValue<T, NAME_VALUE_LOOKUP> { public: - typedef const T value_const_t; - typedef T value_t; - typedef value_const_t& value_assignment_t; + typedef ParamValue<T, NAME_VALUE_LOOKUP> param_value_t; + typedef typename param_value_t::value_assignment_t value_assignment_t; typedef TypedParam<T, NAME_VALUE_LOOKUP, false, true> self_t; typedef NAME_VALUE_LOOKUP name_value_lookup_t; - typedef ParamValue<T, NAME_VALUE_LOOKUP> 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), @@ -808,8 +998,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 +1011,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 +1032,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)) { @@ -870,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; } @@ -884,28 +1070,44 @@ 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); - Param::enclosingBlock().paramChanged(*this, flag_as_provided); + } + + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) + { + return static_cast<self_t&>(param_value_t::operator =(name)); } // 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); + param_value_t::mValidated = false; + setProvided(); + param_value_t::clearValueName(); + } + else + { + Param::enclosingBlock().paramChanged(*this, user_provided); } } 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<const self_t&>(src); @@ -917,7 +1119,6 @@ namespace LLInitParam { dst_typed_param.clearValueName(); dst_typed_param.setProvided(true); - dst_typed_param.enclosingBlock().paramChanged(dst_typed_param, true); return true; } } @@ -936,7 +1137,7 @@ namespace LLInitParam typedef typename std::vector<param_value_t> 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) @@ -1004,7 +1205,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 +1214,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 +1244,33 @@ 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); + param_value_t param_value; + param_value.setValue(item); + mValues.push_back(param_value); + setProvided(); + } + + void add(const typename 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 +1311,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,9 +1327,9 @@ namespace LLInitParam public: typedef TypedParam<VALUE_TYPE, NAME_VALUE_LOOKUP, true, true> self_t; typedef ParamValue<VALUE_TYPE, NAME_VALUE_LOOKUP> param_value_t; - typedef typename std::vector<param_value_t> container_t; + typedef typename std::vector<param_value_t> 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) @@ -1158,8 +1369,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 +1382,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 +1409,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 +1432,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(const typename 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 +1505,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 +1514,25 @@ namespace LLInitParam container_t mValues; }; - template <typename DERIVED_BLOCK> - class ChoiceBlock : public BaseBlock + template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlock> + class ChoiceBlock : public BASE_BLOCK { - typedef ChoiceBlock<DERIVED_BLOCK> self_t; - typedef ChoiceBlock<DERIVED_BLOCK> enclosing_block_t; + typedef ChoiceBlock<DERIVED_BLOCK, BASE_BLOCK> self_t; + typedef ChoiceBlock<DERIVED_BLOCK, BASE_BLOCK> 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<DERIVED_BLOCK*>(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<DERIVED_BLOCK*>(this)->mergeBlock(selfBlockDescriptor(), other, false); } bool mergeBlockParam(bool source_provided, bool dest_provided, BlockDescriptor& block_data, const self_t& source, bool overwrite) @@ -1333,25 +1550,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 +1578,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. @@ -1377,6 +1594,8 @@ namespace LLInitParam typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::value> super_t; typedef typename super_t::value_assignment_t value_assignment_t; + using super_t::operator =; + explicit Alternative(const char* name = "", value_assignment_t val = defaultValue<T>()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1), mOriginalValue(val) @@ -1402,7 +1621,7 @@ namespace LLInitParam super_t::set(val); } - void operator=(value_assignment_t val) + void operator =(value_assignment_t val) { super_t::set(val); } @@ -1447,7 +1666,7 @@ namespace LLInitParam const Param* getCurrentChoice() const { - return BaseBlock::getParamFromHandle(mCurChoice); + return base_block_t::getParamFromHandle(mCurChoice); } }; @@ -1493,13 +1712,16 @@ namespace LLInitParam typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::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<T>()) : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1) { //#pragma message("Parsing LLInitParam::Block::Optional") } - Optional& operator=(value_assignment_t val) + Optional& operator =(value_assignment_t val) { set(val); return *this; @@ -1510,7 +1732,6 @@ namespace LLInitParam super_t::set(val); return static_cast<DERIVED_BLOCK&>(Param::enclosingBlock()); } - using super_t::operator(); }; template <typename T, typename NAME_VALUE_LOOKUP = TypeValues<T> > @@ -1521,12 +1742,15 @@ namespace LLInitParam typedef Mandatory<T, NAME_VALUE_LOOKUP> 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<T>()) : 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; @@ -1537,7 +1761,6 @@ namespace LLInitParam super_t::set(val); return static_cast<DERIVED_BLOCK&>(Param::enclosingBlock()); } - using super_t::operator(); static bool validate(const Param* p) { @@ -1562,7 +1785,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; @@ -1690,18 +1913,15 @@ namespace LLInitParam public: typedef BatchBlock<DERIVED_BLOCK, BASE_BLOCK> block_t; typedef const BatchBlock<DERIVED_BLOCK, BASE_BLOCK>& value_assignment_t; + typedef block_t value_t; 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 +1951,80 @@ namespace LLInitParam return *this; } - S32 mKeyVersion; + protected: + mutable bool mValidated; // lazy validation flag + }; + + template<typename T, bool IS_BLOCK> + class ParamValue <BaseBlock::Lazy<T>, + TypeValues<T>, + IS_BLOCK> + : public IsBlock<T>::base_class_t + { + public: + typedef ParamValue <BaseBlock::Lazy<T>, TypeValues<T>, false> self_t; + typedef const T& value_assignment_t; + typedef T value_t; + + ParamValue() + : mValue(), + mValidated(false) + {} + + ParamValue(value_assignment_t other) + : mValue(other), + 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<T> mValue; }; template <> @@ -1750,15 +2039,11 @@ namespace LLInitParam typedef const LLSD& value_assignment_t; ParamValue() - : mKeyVersion(0), - mValidatedVersion(-1), - mValidated(false) + : mValidated(false) {} ParamValue(value_assignment_t other) : mValue(other), - mKeyVersion(0), - mValidatedVersion(-1), mValidated(false) {} @@ -1770,7 +2055,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); @@ -1782,7 +2066,6 @@ namespace LLInitParam } protected: - mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag private: @@ -1806,14 +2089,14 @@ namespace LLInitParam typedef ParamValue<T, TypeValues<T> > derived_t; typedef CustomParamValue<T> self_t; - typedef Block<derived_t> block_t; + typedef Block<derived_t> block_t; typedef const T& value_assignment_t; + typedef T value_t; + CustomParamValue(const T& value = T()) : mValue(value), mValueAge(VALUE_AUTHORITATIVE), - mKeyVersion(0), - mValidatedVersion(-1), mValidated(false) {} @@ -1966,8 +2249,6 @@ namespace LLInitParam return getValue(); } - S32 mKeyVersion; - protected: // use this from within updateValueFromBlock() to set the value without making it authoritative @@ -2001,7 +2282,6 @@ namespace LLInitParam return block_t::mergeBlock(block_data, source, overwrite); } - mutable S32 mValidatedVersion; mutable bool mValidated; // lazy validation flag private: |