diff options
Diffstat (limited to 'indra/llxuixml/llinitparam.h')
| -rw-r--r-- | indra/llxuixml/llinitparam.h | 1844 |
1 files changed, 1133 insertions, 711 deletions
diff --git a/indra/llxuixml/llinitparam.h b/indra/llxuixml/llinitparam.h index 8cb5bd80fc..4ab1d891a3 100644 --- a/indra/llxuixml/llinitparam.h +++ b/indra/llxuixml/llinitparam.h @@ -1,5 +1,5 @@ /** -f * @file llinitparam.h + * @file llinitparam.h * @brief parameter block abstraction for creating complex objects and * parsing construction parameters from xml and LLSD * @@ -29,18 +29,19 @@ f * @file llinitparam.h #define LL_LLPARAM_H #include <vector> - -#include <stddef.h> #include <boost/function.hpp> -#include <boost/bind.hpp> #include <boost/type_traits/is_convertible.hpp> #include <boost/unordered_map.hpp> -#include "llregistry.h" -#include "llmemory.h" +#include <boost/shared_ptr.hpp> +#include "llerror.h" namespace LLInitParam { + // used to indicate no matching value to a given name when parsing + struct Flag{}; + + template<typename T> const T& defaultValue() { static T value; return value; } template <typename T, bool IS_BOOST_FUNCTION = boost::is_convertible<T, boost::function_base>::value > struct ParamCompare @@ -50,7 +51,7 @@ namespace LLInitParam return a == b; } }; - + // boost function types are not comparable template<typename T> struct ParamCompare<T, true> @@ -61,122 +62,147 @@ namespace LLInitParam } }; - // default constructor adaptor for InitParam Values - // constructs default instances of the given type, returned by const reference - template <typename T> - struct DefaultInitializer + template<> + struct ParamCompare<LLSD, false> { - typedef const T& T_const_ref; - // return reference to a single default instance of T - // built-in types will be initialized to zero, default constructor otherwise - static T_const_ref get() { static T t = T(); return t; } + static bool equals(const LLSD &a, const LLSD &b) { return false; } }; + template<> + struct ParamCompare<Flag, false> + { + static bool equals(const Flag& a, const Flag& b) { return false; } + }; + + // helper functions and classes typedef ptrdiff_t param_handle_t; + // empty default implementation of key cache + // leverages empty base class optimization template <typename T> class TypeValues { + private: + struct Inaccessable{}; public: - // empty default implemenation of key cache - class KeyCache + 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 ""; } + std::string calcValueName(const T& value) const { return ""; } + void clearValueName() const {} + + static bool getValueFromName(const std::string& name, T& value) { - public: - void setKey(const std::string& key) {} - std::string getKey() const { return ""; } - void clearKey(){} - }; + return false; + } - static bool get(const std::string& name, T& value) + static bool valueNamesExist() { return false; } - static bool empty() + static std::vector<std::string>* getPossibleValues() { - return true; + return NULL; } - static std::vector<std::string>* getPossibleValues() { return NULL; } + static value_name_map_t* getValueNames() {return NULL;} }; template <typename T, typename DERIVED_TYPE = TypeValues<T> > class TypeValuesHelper - : public LLRegistrySingleton<std::string, T, DERIVED_TYPE > { - typedef LLRegistrySingleton<std::string, T, DERIVED_TYPE> super_t; - typedef LLSingleton<DERIVED_TYPE> singleton_t; 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 - class KeyCache + void setValueName(const std::string& value_name) { - public: - void setKey(const std::string& key) - { - mKey = key; - } + mValueName = value_name; + } + + std::string getValueName() const + { + return mValueName; + } - void clearKey() + std::string calcValueName(const T& value) const + { + value_name_map_t* map = getValueNames(); + for (typename value_name_map_t::iterator it = map->begin(), end_it = map->end(); + it != end_it; + ++it) { - mKey = ""; + if (ParamCompare<T>::equals(it->second, value)) + { + return it->first; + } } - std::string getKey() const - { - return mKey; - } + return ""; + } - private: - std::string mKey; - }; + void clearValueName() const + { + mValueName.clear(); + } - static bool get(const std::string& name, T& value) + static bool getValueFromName(const std::string& name, T& value) { - if (!singleton_t::instance().exists(name)) return false; + value_name_map_t* map = getValueNames(); + typename value_name_map_t::iterator found_it = map->find(name); + if (found_it == map->end()) return false; - value = *singleton_t::instance().getValue(name); + value = found_it->second; return true; } - static bool empty() + static bool valueNamesExist() { - return singleton_t::instance().LLRegistry<std::string, T>::empty(); + return !getValueNames()->empty(); } - //override this to add name value pairs - static void declareValues() {} - - void initSingleton() + static value_name_map_t* getValueNames() { - DERIVED_TYPE::declareValues(); - } + static value_name_map_t sMap; + static bool sInitialized = false; - static const std::vector<std::string>* getPossibleValues() - { - // in order to return a pointer to a member, we lazily - // evaluate the result and store it in mValues here - if (singleton_t::instance().mValues.empty()) + if (!sInitialized) { - typename super_t::Registrar::registry_map_t::const_iterator it; - for (it = super_t::defaultRegistrar().beginItems(); it != super_t::defaultRegistrar().endItems(); ++it) - { - singleton_t::instance().mValues.push_back(it->first); - } + sInitialized = true; + DERIVED_TYPE::declareValues(); } - return &singleton_t::instance().mValues; + return &sMap; } + static std::vector<std::string>* getPossibleValues() + { + static std::vector<std::string> sValues; + + value_name_map_t* map = getValueNames(); + for (typename value_name_map_t::iterator it = map->begin(), end_it = map->end(); + it != end_it; + ++it) + { + sValues.push_back(it->first); + } + return &sValues; + } - protected: static void declare(const std::string& name, const T& value) { - super_t::defaultRegistrar().add(name, value); + (*getValueNames())[name] = value; } - private: - std::vector<std::string> mValues; + protected: + static void getName(const std::string& name, const T& value) + {} + + mutable std::string mValueName; }; class Parser @@ -193,13 +219,13 @@ namespace LLInitParam } }; - typedef std::vector<std::pair<std::string, S32> > name_stack_t; - typedef std::pair<name_stack_t::const_iterator, name_stack_t::const_iterator> name_stack_range_t; - typedef std::vector<std::string> possible_values_t; + typedef std::vector<std::pair<std::string, bool> > name_stack_t; + typedef std::pair<name_stack_t::iterator, name_stack_t::iterator> name_stack_range_t; + typedef std::vector<std::string> possible_values_t; typedef bool (*parser_read_func_t)(Parser& parser, void* output); - typedef bool (*parser_write_func_t)(Parser& parser, const void*, const name_stack_t&); - typedef boost::function<void (const name_stack_t&, S32, S32, const possible_values_t*)> parser_inspect_func_t; + typedef bool (*parser_write_func_t)(Parser& parser, const void*, name_stack_t&); + typedef boost::function<void (name_stack_t&, S32, S32, const possible_values_t*)> parser_inspect_func_t; typedef std::map<const std::type_info*, parser_read_func_t, CompareTypeID> parser_read_func_map_t; typedef std::map<const std::type_info*, parser_write_func_t, CompareTypeID> parser_write_func_map_t; @@ -207,7 +233,6 @@ namespace LLInitParam Parser(parser_read_func_map_t& read_map, parser_write_func_map_t& write_map, parser_inspect_func_map_t& inspect_map) : mParseSilently(false), - mParseGeneration(0), mParserReadFuncs(&read_map), mParserWriteFuncs(&write_map), mParserInspectFuncs(&inspect_map) @@ -224,7 +249,7 @@ namespace LLInitParam return false; } - template <typename T> bool writeValue(const T& param, const name_stack_t& name_stack) + template <typename T> bool writeValue(const T& param, name_stack_t& name_stack) { parser_write_func_map_t::iterator found_it = mParserWriteFuncs->find(&typeid(T)); if (found_it != mParserWriteFuncs->end()) @@ -235,7 +260,7 @@ namespace LLInitParam } // dispatch inspection to registered inspection functions, for each parameter in a param block - template <typename T> bool inspectValue(const name_stack_t& name_stack, S32 min_count, S32 max_count, const possible_values_t* possible_values) + template <typename T> bool inspectValue(name_stack_t& name_stack, S32 min_count, S32 max_count, const possible_values_t* possible_values) { parser_inspect_func_map_t::iterator found_it = mParserInspectFuncs->find(&typeid(T)); if (found_it != mParserInspectFuncs->end()) @@ -251,10 +276,6 @@ namespace LLInitParam virtual void parserError(const std::string& message); void setParseSilently(bool silent) { mParseSilently = silent; } - S32 getParseGeneration() { return mParseGeneration; } - S32 newParseGeneration() { return ++mParseGeneration; } - - protected: template <typename T> void registerParserFuncs(parser_read_func_t read_func, parser_write_func_t write_func = NULL) @@ -275,83 +296,37 @@ namespace LLInitParam parser_read_func_map_t* mParserReadFuncs; parser_write_func_map_t* mParserWriteFuncs; parser_inspect_func_map_t* mParserInspectFuncs; - S32 mParseGeneration; }; - 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(class 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; - - bool mIsProvided; - U16 mEnclosingBlockOffset; - }; + class Param; // various callbacks and constraints associated with an individual param struct ParamDescriptor { - public: + struct UserData + { + virtual ~UserData() {} + }; + typedef bool(*merge_func_t)(Param&, const Param&, bool); - typedef bool(*deserialize_func_t)(Param&, Parser&, const Parser::name_stack_range_t&, S32); + typedef bool(*deserialize_func_t)(Param&, Parser&, const Parser::name_stack_range_t&, bool); typedef void(*serialize_func_t)(const Param&, Parser&, Parser::name_stack_t&, const Param* diff_param); typedef void(*inspect_func_t)(const Param&, Parser&, Parser::name_stack_t&, S32 min_count, S32 max_count); typedef bool(*validation_func_t)(const Param*); ParamDescriptor(param_handle_t p, - merge_func_t merge_func, - deserialize_func_t deserialize_func, - serialize_func_t serialize_func, - validation_func_t validation_func, - inspect_func_t inspect_func, - S32 min_count, - S32 max_count) - : mParamHandle(p), - mMergeFunc(merge_func), - mDeserializeFunc(deserialize_func), - mSerializeFunc(serialize_func), - mValidationFunc(validation_func), - mInspectFunc(inspect_func), - mMinCount(min_count), - mMaxCount(max_count), - mGeneration(0), - mNumRefs(0) - {} + merge_func_t merge_func, + deserialize_func_t deserialize_func, + serialize_func_t serialize_func, + validation_func_t validation_func, + inspect_func_t inspect_func, + S32 min_count, + S32 max_count); - ParamDescriptor() - : mParamHandle(0), - mMergeFunc(NULL), - mDeserializeFunc(NULL), - mSerializeFunc(NULL), - mValidationFunc(NULL), - mInspectFunc(NULL), - mMinCount(0), - mMaxCount(0), - mGeneration(0), - mNumRefs(0) - {} + ParamDescriptor(); + ~ParamDescriptor(); param_handle_t mParamHandle; - merge_func_t mMergeFunc; deserialize_func_t mDeserializeFunc; serialize_func_t mSerializeFunc; @@ -359,19 +334,17 @@ namespace LLInitParam validation_func_t mValidationFunc; S32 mMinCount; S32 mMaxCount; - S32 mGeneration; S32 mNumRefs; + UserData* mUserData; }; + typedef boost::shared_ptr<ParamDescriptor> ParamDescriptorPtr; + // each derived Block class keeps a static data structure maintaining offsets to various params class BlockDescriptor { public: - BlockDescriptor() - : mMaxParamOffset(0), - mInitializationState(UNINITIALIZED), - mCurrentBlockPtr(NULL) - {} + BlockDescriptor(); typedef enum e_initialization_state { @@ -382,60 +355,135 @@ namespace LLInitParam void aggregateBlockData(BlockDescriptor& src_block_data); - public: - typedef boost::unordered_map<const std::string, ParamDescriptor*> param_map_t; // references param descriptors stored in mAllParams - typedef std::vector<ParamDescriptor*> param_list_t; - - typedef std::list<ParamDescriptor> all_params_list_t;// references param descriptors stored in mAllParams - typedef std::vector<std::pair<param_handle_t, ParamDescriptor::validation_func_t> > param_validation_list_t; + typedef boost::unordered_map<const std::string, ParamDescriptorPtr> param_map_t; + typedef std::vector<ParamDescriptorPtr> param_list_t; + typedef std::list<ParamDescriptorPtr> all_params_list_t; + typedef std::vector<std::pair<param_handle_t, ParamDescriptor::validation_func_t> > param_validation_list_t; param_map_t mNamedParams; // parameters with associated names param_list_t mUnnamedParams; // parameters with_out_ associated names param_validation_list_t mValidationList; // parameters that must be validated all_params_list_t mAllParams; // all parameters, owns descriptors - - size_t mMaxParamOffset; - - EInitializationState mInitializationState; // whether or not static block data has been initialized - class BaseBlock* mCurrentBlockPtr; // pointer to block currently being constructed + size_t mMaxParamOffset; + EInitializationState mInitializationState; // whether or not static block data has been initialized + 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 { - static U32 minCount() { return 0; } - static U32 maxCount() { return U32_MAX; } + enum { minCount = 0 }; + enum { maxCount = U32_MAX }; }; template<U32 MIN_AMOUNT> struct AtLeast { - static U32 minCount() { return MIN_AMOUNT; } - static U32 maxCount() { return U32_MAX; } + enum { minCount = MIN_AMOUNT }; + enum { maxCount = U32_MAX }; }; template<U32 MAX_AMOUNT> struct AtMost { - static U32 minCount() { return 0; } - static U32 maxCount() { return MAX_AMOUNT; } + enum { minCount = 0 }; + enum { maxCount = MAX_AMOUNT }; }; template<U32 MIN_AMOUNT, U32 MAX_AMOUNT> struct Between { - static U32 minCount() { return MIN_AMOUNT; } - static U32 maxCount() { return MAX_AMOUNT; } + enum { minCount = MIN_AMOUNT }; + enum { maxCount = MAX_AMOUNT }; }; template<U32 EXACT_COUNT> struct Exactly { - static U32 minCount() { return EXACT_COUNT; } - static U32 maxCount() { return EXACT_COUNT; } + enum { minCount = EXACT_COUNT }; + enum { maxCount = EXACT_COUNT }; }; // this typedef identifies derived classes as being blocks @@ -443,9 +491,8 @@ namespace LLInitParam LOG_CLASS(BaseBlock); friend class Param; - BaseBlock(); - virtual ~BaseBlock(); - bool submitValue(const Parser::name_stack_t& name_stack, Parser& p, bool silent=false); + virtual ~BaseBlock() {} + bool submitValue(Parser::name_stack_t& name_stack, Parser& p, bool silent=false); param_handle_t getHandleFromParam(const Param* param) const; bool validateBlock(bool emit_errors = true) const; @@ -453,6 +500,7 @@ namespace LLInitParam Param* getParamFromHandle(const param_handle_t param_handle) { if (param_handle == 0) return NULL; + U8* baseblock_address = reinterpret_cast<U8*>(this); return reinterpret_cast<Param*>(baseblock_address + param_handle); } @@ -466,14 +514,11 @@ namespace LLInitParam void addSynonym(Param& param, const std::string& synonym); // Blocks can override this to do custom tracking of changes - virtual void setLastChangedParam(const Param& last_param, bool user_provided); - - S32 getLastChangeVersion() const { return mChangeVersion; } - bool isDefault() const { return mChangeVersion == 0; } + virtual void paramChanged(const Param& changed_param, bool user_provided) {} - bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack); - bool serializeBlock(Parser& p, Parser::name_stack_t name_stack = Parser::name_stack_t(), const BaseBlock* diff_block = NULL) const; - bool inspectBlock(Parser& p, Parser::name_stack_t name_stack = Parser::name_stack_t()) const; + 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; + bool inspectBlock(Parser& p, Parser::name_stack_t name_stack = Parser::name_stack_t(), S32 min_count = 0, S32 max_count = S32_MAX) const; virtual const BlockDescriptor& mostDerivedBlockDescriptor() const { return selfBlockDescriptor(); } virtual BlockDescriptor& mostDerivedBlockDescriptor() { return selfBlockDescriptor(); } @@ -490,16 +535,20 @@ namespace LLInitParam return false; } - static void addParam(BlockDescriptor& block_data, const ParamDescriptor& param, const char* name); + static void addParam(BlockDescriptor& block_data, ParamDescriptorPtr param, const char* name); + + ParamDescriptorPtr findParamDescriptor(const Param& param); + protected: void init(BlockDescriptor& descriptor, BlockDescriptor& base_descriptor, size_t block_size); + bool mergeBlockParam(bool source_provided, bool dst_provided, BlockDescriptor& block_data, const BaseBlock& source, bool overwrite) + { + return mergeBlock(block_data, source, overwrite); + } // take all provided params from other and apply to self - bool merge(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite); - - // can be updated in getters - mutable S32 mChangeVersion; + bool mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite); static BlockDescriptor& selfBlockDescriptor() { @@ -509,30 +558,250 @@ namespace LLInitParam private: const std::string& getParamName(const BlockDescriptor& block_data, const Param* paramp) const; - ParamDescriptor* findParamDescriptor(param_handle_t handle); }; - template<typename T> - struct ParamIterator + struct ParamCompare<BaseBlock::Lazy<T>, false > { - typedef typename std::vector<T>::const_iterator const_iterator; - typedef typename std::vector<T>::iterator iterator; + 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 - // this is supposedly faster than boost::is_convertible and its ilk template<typename T, typename Void = void> - struct IsBaseBlock + 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 IsBaseBlock<T, typename T::baseblock_base_class_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> + class ParamValue : public NAME_VALUE_LOOKUP + { + 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) {} + + void setValue(value_assignment_t val) + { + mValue = val; + } + + value_assignment_t getValue() const + { + return mValue; + } + + T& getValue() + { + return mValue; + } + + operator value_assignment_t() const + { + return mValue; + } + + value_assignment_t operator()() const + { + 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; + } + + protected: + T mValue; + }; + + template<typename T, typename NAME_VALUE_LOOKUP> + class ParamValue<T, NAME_VALUE_LOOKUP, true> + : public T, + public NAME_VALUE_LOOKUP + { + public: + typedef const T& value_assignment_t; + typedef T value_t; + typedef ParamValue<T, NAME_VALUE_LOOKUP, true> self_t; + + ParamValue() + : T(), + mValidated(false) + {} + + ParamValue(value_assignment_t other) + : T(other), + mValidated(false) + {} + + void setValue(value_assignment_t val) + { + *this = val; + } + + value_assignment_t getValue() const + { + return *this; + } + + T& getValue() + { + return *this; + } + + operator value_assignment_t() const + { + return *this; + } + + value_assignment_t operator()() const + { + return *this; + } + + 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 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 + { + typedef typename std::vector<ParamValue<T, NAME_VALUE_LOOKUP> >::const_iterator const_iterator; + typedef typename std::vector<ParamValue<T, NAME_VALUE_LOOKUP> >::iterator iterator; }; // specialize for custom parsing/decomposition of specific classes @@ -540,63 +809,65 @@ namespace LLInitParam template<typename T, typename NAME_VALUE_LOOKUP = TypeValues<T>, bool HAS_MULTIPLE_VALUES = false, - bool VALUE_IS_BLOCK = IsBaseBlock<T>::value> + bool VALUE_IS_BLOCK = IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::value> class TypedParam - : public Param + : public Param, + public ParamValue<T, NAME_VALUE_LOOKUP> { public: - typedef const T& value_const_ref_t; - typedef value_const_ref_t value_assignment_t; - typedef typename NAME_VALUE_LOOKUP::KeyCache key_cache_t; typedef TypedParam<T, NAME_VALUE_LOOKUP, HAS_MULTIPLE_VALUES, VALUE_IS_BLOCK> self_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) { if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING)) { - ParamDescriptor param_descriptor(block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), + ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor( + block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), &mergeWith, &deserializeParam, &serializeParam, validate_func, &inspectParam, - min_count, max_count); + min_count, max_count)); BaseBlock::addParam(block_descriptor, param_descriptor, name); } - mData.mValue = value; + setValue(value); } bool isProvided() const { return Param::anyProvided(); } - static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation) + static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack_range, bool new_name) { self_t& typed_param = static_cast<self_t&>(param); // no further names in stack, attempt to parse value now - if (name_stack.first == name_stack.second) + if (name_stack_range.first == name_stack_range.second) { - if (parser.readValue(typed_param.mData.mValue)) + if (parser.readValue(typed_param.getValue())) { - typed_param.mData.clearKey(); - typed_param.setProvided(true); - typed_param.enclosingBlock().setLastChangedParam(param, true); + typed_param.clearValueName(); + typed_param.setProvided(); return true; } // try to parse a known named value - if(!NAME_VALUE_LOOKUP::empty()) + if(name_value_lookup_t::valueNamesExist()) { // try to parse a known named value std::string name; if (parser.readValue(name)) { // try to parse a per type named value - if (NAME_VALUE_LOOKUP::get(name, typed_param.mData.mValue)) + if (name_value_lookup_t::getValueFromName(name, typed_param.getValue())) { - typed_param.mData.setKey(name); - typed_param.setProvided(true); - typed_param.enclosingBlock().setLastChangedParam(param, true); + typed_param.setValueName(name); + typed_param.setProvided(); return true; } @@ -613,28 +884,30 @@ namespace LLInitParam if (!name_stack.empty()) { - name_stack.back().second = parser.newParseGeneration(); + name_stack.back().second = true; } - std::string key = typed_param.mData.getKey(); + std::string key = typed_param.getValueName(); // first try to write out name of name/value pair if (!key.empty()) { - if (!diff_param || !ParamCompare<std::string>::equals(static_cast<const self_t*>(diff_param)->mData.getKey(), key)) + if (!diff_param || !ParamCompare<std::string>::equals(static_cast<const self_t*>(diff_param)->getValueName(), key)) { - if (!parser.writeValue(key, name_stack)) - { - return; - } + parser.writeValue(key, name_stack); } } // then try to serialize value directly - else if (!diff_param || !ParamCompare<T>::equals(typed_param.get(), static_cast<const self_t*>(diff_param)->get())) { - if (!parser.writeValue(typed_param.mData.mValue, name_stack)) + else if (!diff_param || !ParamCompare<T>::equals(typed_param.getValue(), static_cast<const self_t*>(diff_param)->getValue())) + { + if (!parser.writeValue(typed_param.getValue(), name_stack)) { - return; + std::string calculated_key = typed_param.calcValueName(typed_param.getValue()); + if (!diff_param || !ParamCompare<std::string>::equals(static_cast<const self_t*>(diff_param)->getValueName(), calculated_key)) + { + parser.writeValue(calculated_key, name_stack); + } } } } @@ -644,115 +917,102 @@ namespace LLInitParam // tell parser about our actual type parser.inspectValue<T>(name_stack, min_count, max_count, NULL); // then tell it about string-based alternatives ("red", "blue", etc. for LLColor4) - if (NAME_VALUE_LOOKUP::getPossibleValues()) + if (name_value_lookup_t::getPossibleValues()) { - parser.inspectValue<std::string>(name_stack, min_count, max_count, NAME_VALUE_LOOKUP::getPossibleValues()); + parser.inspectValue<std::string>(name_stack, min_count, max_count, name_value_lookup_t::getPossibleValues()); } } void set(value_assignment_t val, bool flag_as_provided = true) { - mData.mValue = val; - mData.clearKey(); + param_value_t::clearValueName(); + setValue(val); setProvided(flag_as_provided); - Param::enclosingBlock().setLastChangedParam(*this, flag_as_provided); } - void setIfNotProvided(value_assignment_t val, bool flag_as_provided = true) + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) { - if (!isProvided()) - { - set(val, flag_as_provided); - } + return static_cast<self_t&>(param_value_t::operator =(name)); } - // implicit conversion - operator value_assignment_t() const { return get(); } - // explicit conversion - value_assignment_t operator()() const { return get(); } - protected: - value_assignment_t get() const + + self_t& operator =(const self_t& other) { - return mData.mValue; + 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); self_t& dst_typed_param = static_cast<self_t&>(dst); + if (src_typed_param.isProvided() && (overwrite || !dst_typed_param.isProvided())) { - dst_typed_param.mData.clearKey(); - dst_typed_param.set(src_typed_param.get()); + dst_typed_param.set(src_typed_param.getValue()); return true; } return false; } - - struct Data : public key_cache_t - { - T mValue; - }; - - Data mData; }; // parameter that is a block template <typename T, typename NAME_VALUE_LOOKUP> class TypedParam<T, NAME_VALUE_LOOKUP, false, true> - : public T, - public Param + : public Param, + public ParamValue<T, NAME_VALUE_LOOKUP> { public: - typedef const T value_const_t; - typedef T value_t; - typedef value_const_t& value_const_ref_t; - typedef value_const_ref_t value_assignment_t; - typedef typename NAME_VALUE_LOOKUP::KeyCache key_cache_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; + + 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), - T(value) + param_value_t(value) { if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING)) { - ParamDescriptor param_descriptor(block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), + ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor( + block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), &mergeWith, &deserializeParam, &serializeParam, validate_func, &inspectParam, - min_count, max_count); + min_count, max_count)); BaseBlock::addParam(block_descriptor, param_descriptor, name); } } - static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation) + static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack_range, bool new_name) { self_t& typed_param = static_cast<self_t&>(param); // attempt to parse block... - if(typed_param.deserializeBlock(parser, name_stack)) + if(typed_param.deserializeBlock(parser, name_stack_range, new_name)) { - typed_param.mData.clearKey(); - typed_param.enclosingBlock().setLastChangedParam(param, true); + typed_param.clearValueName(); + typed_param.setProvided(); return true; } - if(!NAME_VALUE_LOOKUP::empty()) + if(name_value_lookup_t::valueNamesExist()) { // try to parse a known named value std::string name; if (parser.readValue(name)) { // try to parse a per type named value - if (NAME_VALUE_LOOKUP::get(name, typed_param)) + if (name_value_lookup_t::getValueFromName(name, typed_param.getValue())) { - typed_param.enclosingBlock().setLastChangedParam(param, true); - typed_param.mData.setKey(name); - typed_param.mData.mKeyVersion = typed_param.getLastChangeVersion(); + typed_param.setValueName(name); + typed_param.setProvided(); return true; } @@ -764,13 +1024,15 @@ namespace LLInitParam 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<const self_t&>(param); + if (!typed_param.isProvided()) return; + if (!name_stack.empty()) { - name_stack.back().second = parser.newParseGeneration(); + name_stack.back().second = true; } - std::string key = typed_param.mData.getKey(); - if (!key.empty() && typed_param.mData.mKeyVersion == typed_param.getLastChangeVersion()) + std::string key = typed_param.getValueName(); + if (!key.empty()) { if (!parser.writeValue(key, name_stack)) { @@ -787,64 +1049,62 @@ namespace LLInitParam { // I am a param that is also a block, so just recurse into my contents const self_t& typed_param = static_cast<const self_t&>(param); - typed_param.inspectBlock(parser, name_stack); + typed_param.inspectBlock(parser, name_stack, min_count, max_count); } // a param-that-is-a-block is provided when the user has set one of its child params // *and* the block as a whole validates bool isProvided() const { - // only validate block when it hasn't already passed validation and user has supplied *some* value - if (Param::anyProvided() && mData.mValidatedVersion < T::getLastChangeVersion()) + // only validate block when it hasn't already passed validation with current data + if (Param::anyProvided() && !param_value_t::mValidated) { // a sub-block is "provided" when it has been filled in enough to be valid - mData.mValidated = T::validateBlock(false); - mData.mValidatedVersion = T::getLastChangeVersion(); + param_value_t::mValidated = param_value_t::validateBlock(false); } - return Param::anyProvided() && mData.mValidated; + return Param::anyProvided() && param_value_t::mValidated; } // assign block contents to this param-that-is-a-block void set(value_assignment_t val, bool flag_as_provided = true) { - value_t::operator=(val); - mData.clearKey(); - // force revalidation of block by clearing known provided version + setValue(val); + param_value_t::clearValueName(); + // force revalidation of block // next call to isProvided() will update provision status based on validity - mData.mValidatedVersion = 0; + param_value_t::mValidated = false; setProvided(flag_as_provided); - Param::enclosingBlock().setLastChangedParam(*this, flag_as_provided); } - void setIfNotProvided(value_assignment_t val, bool flag_as_provided = true) + self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name) { - if (!isProvided()) - { - set(val, flag_as_provided); - } + return static_cast<self_t&>(param_value_t::operator =(name)); } // propagate changed status up to enclosing block - /*virtual*/ void setLastChangedParam(const Param& last_param, bool user_provided) + /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { - T::setLastChangedParam(last_param, user_provided); - Param::enclosingBlock().setLastChangedParam(*this, user_provided); + param_value_t::paramChanged(changed_param, 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); } } - // implicit conversion - operator value_assignment_t() const { return get(); } - // explicit conversion - value_assignment_t operator()() const { return get(); } - protected: - value_assignment_t get() const + + self_t& operator =(const self_t& other) { + param_value_t::operator =(other); + Param::operator =(other); return *this; } @@ -852,27 +1112,18 @@ namespace LLInitParam { const self_t& src_typed_param = static_cast<const self_t&>(src); self_t& dst_typed_param = static_cast<self_t&>(dst); - if (dst_typed_param.T::merge(T::selfBlockDescriptor(), src_typed_param, overwrite)) + + if (src_typed_param.anyProvided()) { - dst_typed_param.mData.clearKey(); - return true; + if (dst_typed_param.mergeBlockParam(src_typed_param.isProvided(), dst_typed_param.isProvided(), param_value_t::selfBlockDescriptor(), src_typed_param, overwrite)) + { + dst_typed_param.clearValueName(); + dst_typed_param.setProvided(true); + return true; + } } return false; } - - struct Data : public key_cache_t - { - S32 mKeyVersion; - mutable S32 mValidatedVersion; - mutable bool mValidated; // lazy validation flag - - Data() - : mKeyVersion(0), - mValidatedVersion(0), - mValidated(false) - {} - }; - Data mData; }; // container of non-block parameters @@ -882,68 +1133,60 @@ namespace LLInitParam { public: typedef TypedParam<VALUE_TYPE, NAME_VALUE_LOOKUP, true, false> self_t; - typedef typename std::vector<VALUE_TYPE> container_t; + typedef ParamValue<VALUE_TYPE, NAME_VALUE_LOOKUP> param_value_t; + typedef typename std::vector<param_value_t> container_t; typedef const container_t& value_assignment_t; - typedef VALUE_TYPE value_t; - typedef value_t& value_ref_t; - typedef const value_t& value_const_ref_t; + typedef typename param_value_t::value_t value_t; + typedef NAME_VALUE_LOOKUP name_value_lookup_t; - typedef typename NAME_VALUE_LOOKUP::KeyCache key_cache_t; - 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), - mValues(value) + : Param(block_descriptor.mCurrentBlockPtr) { - mCachedKeys.resize(mValues.size()); + std::copy(value.begin(), value.end(), std::back_inserter(mValues)); + if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING)) { - ParamDescriptor param_descriptor(block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), + ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor( + block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), &mergeWith, &deserializeParam, &serializeParam, validate_func, &inspectParam, - min_count, max_count); + min_count, max_count)); BaseBlock::addParam(block_descriptor, param_descriptor, name); } } bool isProvided() const { return Param::anyProvided(); } - static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation) + static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack_range, bool new_name) { self_t& typed_param = static_cast<self_t&>(param); value_t value; // no further names in stack, attempt to parse value now - if (name_stack.first == name_stack.second) + if (name_stack_range.first == name_stack_range.second) { // attempt to read value directly if (parser.readValue(value)) { - typed_param.mValues.push_back(value); - // save an empty name/value key as a placeholder - typed_param.mCachedKeys.push_back(key_cache_t()); - typed_param.enclosingBlock().setLastChangedParam(param, true); - typed_param.setProvided(true); + typed_param.add(value); return true; } // try to parse a known named value - if(!NAME_VALUE_LOOKUP::empty()) + if(name_value_lookup_t::valueNamesExist()) { // try to parse a known named value std::string name; if (parser.readValue(name)) { // try to parse a per type named value - if (NAME_VALUE_LOOKUP::get(name, typed_param.mValues)) + if (name_value_lookup_t::getValueFromName(name, value)) { - typed_param.mValues.push_back(value); - typed_param.mCachedKeys.push_back(key_cache_t()); - typed_param.mCachedKeys.back().setKey(name); - typed_param.enclosingBlock().setLastChangedParam(param, true); - typed_param.setProvided(true); + typed_param.add(value); + typed_param.mValues.back().setValueName(name); return true; } @@ -958,25 +1201,32 @@ namespace LLInitParam const self_t& typed_param = static_cast<const self_t&>(param); if (!typed_param.isProvided() || name_stack.empty()) return; - const_iterator it = typed_param.mValues.begin(); - for (typename std::vector<key_cache_t>::const_iterator key_it = typed_param.mCachedKeys.begin(); - it != typed_param.mValues.end(); - ++key_it, ++it) + for (const_iterator it = typed_param.mValues.begin(), end_it = typed_param.mValues.end(); + it != end_it; + ++it) { - std::string key = key_it->get(); - name_stack.back().second = parser.newParseGeneration(); + std::string key = it->getValueName(); + name_stack.back().second = true; - if(!key.empty()) + if(key.empty()) + // not parsed via name values, write out value directly { - if(!parser.writeValue(key, name_stack)) + bool value_written = parser.writeValue(*it, name_stack); + if (!value_written) { - return; + std::string calculated_key = it->calcValueName(it->getValue()); + if (!parser.writeValue(calculated_key, name_stack)) + { + break; + } } } - // not parse via name values, write out value directly - else if (!parser.writeValue(*it, name_stack)) + else { - return; + if(!parser.writeValue(key, name_stack)) + { + break; + } } } } @@ -984,47 +1234,52 @@ namespace LLInitParam static void inspectParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, S32 min_count, S32 max_count) { parser.inspectValue<VALUE_TYPE>(name_stack, min_count, max_count, NULL); - if (NAME_VALUE_LOOKUP::getPossibleValues()) + if (name_value_lookup_t::getPossibleValues()) { - parser.inspectValue<std::string>(name_stack, min_count, max_count, NAME_VALUE_LOOKUP::getPossibleValues()); + parser.inspectValue<std::string>(name_stack, min_count, max_count, name_value_lookup_t::getPossibleValues()); } } void set(value_assignment_t val, bool flag_as_provided = true) { mValues = val; - mCachedKeys.clear(); - mCachedKeys.resize(mValues.size()); setProvided(flag_as_provided); - Param::enclosingBlock().setLastChangedParam(*this, flag_as_provided); } - - void setIfNotProvided(value_assignment_t val, bool flag_as_provided = true) + param_value_t& add() { - if (!isProvided()) - { - set(val, flag_as_provided); - } + mValues.push_back(param_value_t(value_t())); + Param::setProvided(); + return mValues.back(); } - value_ref_t add() + self_t& add(const value_t& item) { - mValues.push_back(value_t()); - mCachedKeys.push_back(key_cache_t()); - setProvided(true); - return mValues.back(); + param_value_t param_value; + param_value.setValue(item); + mValues.push_back(param_value); + setProvided(); + return *this; } - void add(value_const_ref_t item) + self_t& add(const typename name_value_lookup_t::name_t& name) { - mValues.push_back(item); - mCachedKeys.push_back(key_cache_t()); - setProvided(true); + 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); + } + + return *this; } // implicit conversion - operator value_assignment_t() const { return self_t::get(); } + operator value_assignment_t() const { return mValues; } + // explicit conversion + value_assignment_t operator()() const { return mValues; } typedef typename container_t::iterator iterator; typedef typename container_t::const_iterator const_iterator; @@ -1041,27 +1296,30 @@ namespace LLInitParam } protected: - value_assignment_t get() const - { - return mValues; - } - static bool mergeWith(Param& dst, const Param& src, bool overwrite) { const self_t& src_typed_param = static_cast<const self_t&>(src); self_t& dst_typed_param = static_cast<self_t&>(dst); - if (src_typed_param.isProvided() - && (overwrite || !dst_typed_param.isProvided())) + if (overwrite) { - dst_typed_param.set(src_typed_param.get()); - return true; + std::copy(src_typed_param.begin(), src_typed_param.end(), std::back_inserter(dst_typed_param.mValues)); } - return false; + else + { + container_t new_values(src_typed_param.mValues); + std::copy(dst_typed_param.begin(), dst_typed_param.end(), std::back_inserter(new_values)); + std::swap(dst_typed_param.mValues, new_values); + } + + if (src_typed_param.begin() != src_typed_param.end()) + { + dst_typed_param.setProvided(); + } + return true; } container_t mValues; - std::vector<key_cache_t> mCachedKeys; }; // container of block parameters @@ -1071,81 +1329,63 @@ namespace LLInitParam { public: typedef TypedParam<VALUE_TYPE, NAME_VALUE_LOOKUP, true, true> self_t; - typedef typename std::vector<VALUE_TYPE> container_t; + typedef ParamValue<VALUE_TYPE, NAME_VALUE_LOOKUP> param_value_t; + typedef typename std::vector<param_value_t> container_t; typedef const container_t& value_assignment_t; - - typedef VALUE_TYPE value_t; - typedef value_t& value_ref_t; - typedef const value_t& value_const_ref_t; - - typedef typename NAME_VALUE_LOOKUP::KeyCache key_cache_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) - : Param(block_descriptor.mCurrentBlockPtr), - mValues(value), - mLastParamGeneration(0) + : Param(block_descriptor.mCurrentBlockPtr) { - mCachedKeys.resize(mValues.size()); + std::copy(value.begin(), value.end(), back_inserter(mValues)); + if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING)) { - ParamDescriptor param_descriptor(block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), + ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor( + block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), &mergeWith, &deserializeParam, &serializeParam, validate_func, &inspectParam, - min_count, max_count); + min_count, max_count)); BaseBlock::addParam(block_descriptor, param_descriptor, name); } } bool isProvided() const { return Param::anyProvided(); } - value_ref_t operator[](S32 index) { return mValues[index]; } - value_const_ref_t operator[](S32 index) const { return mValues[index]; } - - static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation) + static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack_range, bool new_name) { self_t& typed_param = static_cast<self_t&>(param); bool new_value = false; - if (generation != typed_param.mLastParamGeneration || typed_param.mValues.empty()) + + if (new_name || typed_param.mValues.empty()) { new_value = true; typed_param.mValues.push_back(value_t()); - typed_param.mCachedKeys.push_back(Data()); } - value_ref_t value = typed_param.mValues.back(); + param_value_t& value = typed_param.mValues.back(); // attempt to parse block... - if(value.deserializeBlock(parser, name_stack)) + if(value.deserializeBlock(parser, name_stack_range, new_name)) { - if (new_value) - { // successfully parsed new value, let's keep it - typed_param.mLastParamGeneration = generation; - } - typed_param.enclosingBlock().setLastChangedParam(param, true); - typed_param.setProvided(true); + typed_param.setProvided(); return true; } - else if(!NAME_VALUE_LOOKUP::empty()) + else if(name_value_lookup_t::valueNamesExist()) { // try to parse a known named value std::string name; if (parser.readValue(name)) { // try to parse a per type named value - if (NAME_VALUE_LOOKUP::get(name, value)) + if (name_value_lookup_t::getValueFromName(name, value.getValue())) { - if (new_value) - { // successfully parsed new value, let's keep it - typed_param.mLastParamGeneration = generation; - } - - typed_param.mCachedKeys.back().setKey(name); - typed_param.mCachedKeys.back().mKeyVersion = value.getLastChangeVersion(); - typed_param.enclosingBlock().setLastChangedParam(param, true); - typed_param.setProvided(true); + typed_param.mValues.back().setValueName(name); + typed_param.setProvided(); return true; } @@ -1155,7 +1395,6 @@ namespace LLInitParam if (new_value) { // failed to parse new value, pop it off typed_param.mValues.pop_back(); - typed_param.mCachedKeys.pop_back(); } return false; @@ -1166,26 +1405,22 @@ namespace LLInitParam const self_t& typed_param = static_cast<const self_t&>(param); if (!typed_param.isProvided() || name_stack.empty()) return; - const_iterator it = typed_param.mValues.begin(); - for (typename std::vector<Data>::const_iterator key_it = typed_param.mCachedKeys.begin(); - it != typed_param.mValues.end(); - ++key_it, ++it) + for (const_iterator it = typed_param.mValues.begin(), end_it = typed_param.mValues.end(); + it != end_it; + ++it) { - name_stack.back().second = parser.newParseGeneration(); + name_stack.back().second = true; - std::string key = key_it->getKey(); - if (!key.empty() && key_it->mKeyVersion == it->getLastChangeVersion()) + std::string key = it->getValueName(); + if (!key.empty()) { - if(!parser.writeValue(key, name_stack)) - { - return; - } + parser.writeValue(key, name_stack); } // Not parsed via named values, write out value directly // NOTE: currently we don't worry about removing default values in Multiple - else if (!it->serializeBlock(parser, name_stack, NULL)) + else { - return; + it->serializeBlock(parser, name_stack, NULL); } } } @@ -1193,43 +1428,46 @@ namespace LLInitParam static void inspectParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, S32 min_count, S32 max_count) { // I am a vector of blocks, so describe my contents recursively - value_t().inspectBlock(parser, name_stack); + param_value_t(value_t()).inspectBlock(parser, name_stack, min_count, max_count); } void set(value_assignment_t val, bool flag_as_provided = true) { mValues = val; - mCachedKeys.clear(); - mCachedKeys.resize(mValues.size()); setProvided(flag_as_provided); - Param::enclosingBlock().setLastChangedParam(*this, flag_as_provided); } - void setIfNotProvided(value_assignment_t val, bool flag_as_provided = true) - { - if (!isProvided()) - { - set(val, flag_as_provided); - } - } - - value_ref_t add() + param_value_t& add() { mValues.push_back(value_t()); - mCachedKeys.push_back(Data()); - setProvided(true); + setProvided(); return mValues.back(); } - void add(value_const_ref_t item) + self_t& add(const value_t& item) { mValues.push_back(item); - mCachedKeys.push_back(Data()); - setProvided(true); + setProvided(); + return *this; + } + + self_t& 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); + } + return *this; } // implicit conversion - operator value_assignment_t() const { return self_t::get(); } + operator value_assignment_t() const { return mValues; } + // explicit conversion + value_assignment_t operator()() const { return mValues; } typedef typename container_t::iterator iterator; typedef typename container_t::const_iterator const_iterator; @@ -1243,8 +1481,8 @@ namespace LLInitParam U32 numValidElements() const { U32 count = 0; - for (const_iterator it = mValues.begin(); - it != mValues.end(); + for (const_iterator it = mValues.begin(), end_it = mValues.end(); + it != end_it; ++it) { if(it->validateBlock(false)) count++; @@ -1253,96 +1491,99 @@ namespace LLInitParam } protected: - value_assignment_t get() const - { - return mValues; - } static bool mergeWith(Param& dst, const Param& src, bool overwrite) { const self_t& src_typed_param = static_cast<const self_t&>(src); self_t& dst_typed_param = static_cast<self_t&>(dst); - if (src_typed_param.isProvided() - && (overwrite || !dst_typed_param.isProvided())) + if (overwrite) { - dst_typed_param.set(src_typed_param.get()); - return true; + std::copy(src_typed_param.begin(), src_typed_param.end(), std::back_inserter(dst_typed_param.mValues)); + } + else + { + container_t new_values(src_typed_param.mValues); + std::copy(dst_typed_param.begin(), dst_typed_param.end(), std::back_inserter(new_values)); + std::swap(dst_typed_param.mValues, new_values); } - return false; - } - struct Data : public key_cache_t - { - S32 mKeyVersion; // version of block for which key was last valid + if (src_typed_param.begin() != src_typed_param.end()) + { + dst_typed_param.setProvided(); + } - Data() : mKeyVersion(0) {} - }; + return true; + } container_t mValues; - std::vector<Data> mCachedKeys; - - S32 mLastParamGeneration; }; - template <typename DERIVED_BLOCK> - class Choice : public BaseBlock + template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlock> + class ChoiceBlock : public BASE_BLOCK { - typedef Choice<DERIVED_BLOCK> self_t; - typedef Choice<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 merge(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 merge(selfBlockDescriptor(), other, false); + return static_cast<DERIVED_BLOCK*>(this)->mergeBlock(selfBlockDescriptor(), other, false); } - // merge with other block - bool merge(BlockDescriptor& block_data, const self_t& other, bool overwrite) + bool mergeBlockParam(bool source_provided, bool dest_provided, BlockDescriptor& block_data, const self_t& source, bool overwrite) { - // only merge a choice if we are overwriting with other's contents - if (overwrite) + bool source_override = source_provided && (overwrite || !dest_provided); + + if (source_override || source.mCurChoice == mCurChoice) { - mCurChoice = other.mCurChoice; - return BaseBlock::merge(selfBlockDescriptor(), other, overwrite); + return mergeBlock(block_data, source, overwrite); } return false; } + // merge with other block + bool mergeBlock(BlockDescriptor& block_data, const self_t& other, bool overwrite) + { + mCurChoice = other.mCurChoice; + return base_block_t::mergeBlock(selfBlockDescriptor(), other, overwrite); + } + // clear out old choice when param has changed - /*virtual*/ void setLastChangedParam(const Param& last_param, bool user_provided) + /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { - param_handle_t changed_param_handle = BaseBlock::getHandleFromParam(&last_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::setLastChangedParam(last_param, user_provided); + base_block_t::paramChanged(changed_param, user_provided); } virtual const BlockDescriptor& mostDerivedBlockDescriptor() const { return selfBlockDescriptor(); } virtual BlockDescriptor& mostDerivedBlockDescriptor() { return selfBlockDescriptor(); } protected: - Choice() + 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. @@ -1352,30 +1593,42 @@ namespace LLInitParam class Alternative : public TypedParam<T, NAME_VALUE_LOOKUP, false> { public: - friend class Choice<DERIVED_BLOCK>; + friend class ChoiceBlock<DERIVED_BLOCK>; typedef Alternative<T, NAME_VALUE_LOOKUP> self_t; - typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBaseBlock<T>::value> super_t; + 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; - explicit Alternative(const char* name, value_assignment_t val = DefaultInitializer<T>::get()) + 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) { // assign initial choice to first declared option DERIVED_BLOCK* blockp = ((DERIVED_BLOCK*)DERIVED_BLOCK::selfBlockDescriptor().mCurrentBlockPtr); - if (LL_UNLIKELY( - DERIVED_BLOCK::selfBlockDescriptor().mInitializationState == BlockDescriptor::INITIALIZING - && blockp->mCurChoice == 0)) + if (LL_UNLIKELY(DERIVED_BLOCK::selfBlockDescriptor().mInitializationState == BlockDescriptor::INITIALIZING)) { - blockp->mCurChoice = Param::enclosingBlock().getHandleFromParam(this); + if(blockp->mCurChoice == 0) + { + blockp->mCurChoice = Param::enclosingBlock().getHandleFromParam(this); + } } } - Alternative& operator=(value_assignment_t val) + void choose() + { + static_cast<enclosing_block_t&>(Param::enclosingBlock()).paramChanged(*this, true); + } + + void chooseAs(value_assignment_t val) + { + super_t::set(val); + } + + void operator =(value_assignment_t val) { super_t::set(val); - return *this; } void operator()(typename super_t::value_assignment_t val) @@ -1384,19 +1637,15 @@ namespace LLInitParam } operator value_assignment_t() const - { - if (static_cast<enclosing_block_t&>(Param::enclosingBlock()).getCurrentChoice() == this) - { - return super_t::get(); - } - return mOriginalValue; + { + return (*this)(); } value_assignment_t operator()() const { if (static_cast<enclosing_block_t&>(Param::enclosingBlock()).getCurrentChoice() == this) { - return super_t::get(); + return super_t::getValue(); } return mOriginalValue; } @@ -1422,7 +1671,7 @@ namespace LLInitParam const Param* getCurrentChoice() const { - return BaseBlock::getParamFromHandle(mCurChoice); + return base_block_t::getParamFromHandle(mCurChoice); } }; @@ -1430,8 +1679,8 @@ namespace LLInitParam class Block : public BASE_BLOCK { - typedef Block<DERIVED_BLOCK, BASE_BLOCK> self_t; - typedef Block<DERIVED_BLOCK, BASE_BLOCK> block_t; + typedef Block<DERIVED_BLOCK, BASE_BLOCK> self_t; + typedef Block<DERIVED_BLOCK, BASE_BLOCK> block_t; public: typedef BASE_BLOCK base_block_t; @@ -1439,13 +1688,13 @@ namespace LLInitParam // take all provided params from other and apply to self bool overwriteFrom(const self_t& other) { - return BaseBlock::merge(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 BaseBlock::merge(selfBlockDescriptor(), other, false); + return static_cast<DERIVED_BLOCK*>(this)->mergeBlock(selfBlockDescriptor(), other, false); } virtual const BlockDescriptor& mostDerivedBlockDescriptor() const { return selfBlockDescriptor(); } @@ -1465,43 +1714,48 @@ namespace LLInitParam class Optional : public TypedParam<T, NAME_VALUE_LOOKUP, false> { public: - typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBaseBlock<T>::value> super_t; + 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; - explicit Optional(const char* name = "", value_assignment_t val = DefaultInitializer<T>::get()) + 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; } - DERIVED_BLOCK& operator()(typename super_t::value_assignment_t val) + DERIVED_BLOCK& operator()(value_assignment_t val) { super_t::set(val); return static_cast<DERIVED_BLOCK&>(Param::enclosingBlock()); } - using super_t::operator(); }; template <typename T, typename NAME_VALUE_LOOKUP = TypeValues<T> > class Mandatory : public TypedParam<T, NAME_VALUE_LOOKUP, false> { public: - typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBaseBlock<T>::value> super_t; + typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::value> super_t; 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 = DefaultInitializer<T>::get()) + 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; @@ -1512,7 +1766,6 @@ namespace LLInitParam super_t::set(val); return static_cast<DERIVED_BLOCK&>(Param::enclosingBlock()); } - using super_t::operator(); static bool validate(const Param* p) { @@ -1526,23 +1779,23 @@ namespace LLInitParam class Multiple : public TypedParam<T, NAME_VALUE_LOOKUP, true> { public: - typedef TypedParam<T, NAME_VALUE_LOOKUP, true, IsBaseBlock<T>::value> super_t; + typedef TypedParam<T, NAME_VALUE_LOOKUP, true, IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::value> super_t; typedef Multiple<T, RANGE, NAME_VALUE_LOOKUP> self_t; typedef typename super_t::container_t container_t; typedef typename super_t::value_assignment_t value_assignment_t; typedef typename super_t::iterator iterator; typedef typename super_t::const_iterator const_iterator; - explicit Multiple(const char* name = "", value_assignment_t val = DefaultInitializer<container_t>::get()) - : super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, &validate, RANGE::minCount(), RANGE::maxCount()) + explicit Multiple(const char* name = "") + : 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; } - + DERIVED_BLOCK& operator()(typename super_t::value_assignment_t val) { super_t::set(val); @@ -1552,7 +1805,7 @@ namespace LLInitParam static bool validate(const Param* paramp) { U32 num_valid = ((super_t*)paramp)->numValidElements(); - return RANGE::minCount() <= num_valid && num_valid <= RANGE::maxCount(); + return RANGE::minCount <= num_valid && num_valid <= RANGE::maxCount; } }; @@ -1565,20 +1818,21 @@ namespace LLInitParam BlockDescriptor& block_descriptor = DERIVED_BLOCK::selfBlockDescriptor(); if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING)) { - ParamDescriptor param_descriptor(block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), + ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor( + block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), NULL, &deserializeParam, NULL, NULL, NULL, - 0, S32_MAX); + 0, S32_MAX)); BaseBlock::addParam(block_descriptor, param_descriptor, name); } } - static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation) + static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack_range, bool new_name) { - if (name_stack.first == name_stack.second) + if (name_stack_range.first == name_stack_range.second) { //std::string message = llformat("Deprecated value %s ignored", getName().c_str()); //parser.parserWarning(message); @@ -1589,6 +1843,7 @@ namespace LLInitParam } }; + // different semantics for documentation purposes, but functionally identical typedef Deprecated Ignored; protected: @@ -1597,139 +1852,327 @@ namespace LLInitParam static BlockDescriptor sBlockDescriptor; return sBlockDescriptor; } + + template <typename T, typename NAME_VALUE_LOOKUP, bool multiple, bool is_block> + void changeDefault(TypedParam<T, NAME_VALUE_LOOKUP, multiple, is_block>& param, + typename TypedParam<T, NAME_VALUE_LOOKUP, multiple, is_block>::value_assignment_t value) + { + if (!param.isProvided()) + { + param.set(value, false); + } + } + }; - template<typename T, typename DERIVED = TypedParam<T> > - class BlockValue - : public Block<TypedParam<T, TypeValues<T>, false> >, - public Param + template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlock> + class BatchBlock + : public Block<DERIVED_BLOCK, BASE_BLOCK> { public: - typedef enum e_value_age - { - OLDER_THAN_BLOCK, // mData.mValue needs to be refreshed from the block parameters - NEWER_THAN_BLOCK, // mData.mValue holds the authoritative value (which has been replicated to the block parameters via setBlockFromValue) - SAME_AS_BLOCK // mData.mValue is derived from the block parameters, which are authoritative - } EValueAge; + typedef BatchBlock<DERIVED_BLOCK, BASE_BLOCK> self_t; + typedef Block<DERIVED_BLOCK, BASE_BLOCK> super_t; - typedef BlockValue<T> self_t; - typedef Block<TypedParam<T, TypeValues<T>, false> > block_t; - typedef const T& value_const_ref_t; - typedef value_const_ref_t value_assignment_t; - typedef typename TypeValues<T>::KeyCache key_cache_t; + BatchBlock() + {} - BlockValue(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), - mData(value, NEWER_THAN_BLOCK) + bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool new_name) { - if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING)) + if (new_name) { - ParamDescriptor param_descriptor(block_descriptor.mCurrentBlockPtr->getHandleFromParam(this), - &mergeWith, - &deserializeParam, - &serializeParam, - validate_func, - &inspectParam, - min_count, max_count); - BaseBlock::addParam(block_descriptor, param_descriptor, name); + // reset block + *static_cast<DERIVED_BLOCK*>(this) = defaultBatchValue(); } + return super_t::deserializeBlock(p, name_stack_range, new_name); } - // implicit conversion - operator value_assignment_t() const { return get(); } - // explicit conversion - value_assignment_t operator()() const { return get(); } - - static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation) + bool mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite) { - DERIVED& typed_param = static_cast<DERIVED&>(param); - // type to apply parse direct value T - if (name_stack.first == name_stack.second) + if (overwrite) { - if(parser.readValue(typed_param.mData.mValue)) - { - typed_param.enclosingBlock().setLastChangedParam(param, true); - typed_param.setProvided(true); - typed_param.mData.clearKey(); - typed_param.mData.mValueAge = NEWER_THAN_BLOCK; - typed_param.setBlockFromValue(); + *static_cast<DERIVED_BLOCK*>(this) = defaultBatchValue(); + // merge individual parameters into destination + return super_t::mergeBlock(super_t::selfBlockDescriptor(), other, overwrite); + } + return false; + } + protected: + static const DERIVED_BLOCK& defaultBatchValue() + { + static DERIVED_BLOCK default_value; + return default_value; + } + }; - return true; - } + // FIXME: this specialization is not currently used, as it only matches against the BatchBlock base class + // and not the derived class with the actual params + template<typename DERIVED_BLOCK, + typename BASE_BLOCK, + typename NAME_VALUE_LOOKUP> + class ParamValue <BatchBlock<DERIVED_BLOCK, BASE_BLOCK>, + NAME_VALUE_LOOKUP, + true> + : public NAME_VALUE_LOOKUP, + protected BatchBlock<DERIVED_BLOCK, BASE_BLOCK> + { + 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(), + mValidated(false) + {} + + ParamValue(value_assignment_t other) + : block_t(other), + mValidated(false) + { + } + + void setValue(value_assignment_t val) + { + *this = val; + } + + value_assignment_t getValue() const + { + return *this; + } + + BatchBlock<DERIVED_BLOCK, BASE_BLOCK>& getValue() + { + return *this; + } + + operator value_assignment_t() const + { + return *this; + } - if(!TypeValues<T>::empty()) + value_assignment_t operator()() const + { + return *this; + } + + 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 bool mValidated; // lazy validation flag + + private: + BaseBlock::Lazy<T> mValue; + }; + + template <> + class ParamValue <LLSD, + TypeValues<LLSD>, + false> + : public TypeValues<LLSD>, + public BaseBlock + { + public: + typedef ParamValue<LLSD, TypeValues<LLSD>, false> self_t; + typedef const LLSD& value_assignment_t; + + ParamValue() + : mValidated(false) + {} + + ParamValue(value_assignment_t other) + : mValue(other), + mValidated(false) + {} + + void setValue(value_assignment_t val) { mValue = val; } + + value_assignment_t getValue() const { return mValue; } + LLSD& getValue() { return mValue; } + + operator value_assignment_t() const { return mValue; } + value_assignment_t operator()() const { return mValue; } + + + // block param interface + 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; + bool inspectBlock(Parser& p, Parser::name_stack_t name_stack = Parser::name_stack_t(), S32 min_count = 0, S32 max_count = S32_MAX) const + { + //TODO: implement LLSD params as schema type Any + return true; + } + + protected: + mutable bool mValidated; // lazy validation flag + + private: + static void serializeElement(Parser& p, const LLSD& sd, Parser::name_stack_t& name_stack); + + LLSD mValue; + }; + + template<typename T> + class CustomParamValue + : public Block<ParamValue<T, TypeValues<T> > >, + public TypeValues<T> + { + public: + typedef enum e_value_age + { + VALUE_NEEDS_UPDATE, // mValue needs to be refreshed from the block parameters + VALUE_AUTHORITATIVE, // mValue holds the authoritative value (which has been replicated to the block parameters via updateBlockFromValue) + BLOCK_AUTHORITATIVE // mValue is derived from the block parameters, which are authoritative + } EValueAge; + + typedef ParamValue<T, TypeValues<T> > derived_t; + typedef CustomParamValue<T> self_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), + mValidated(false) + {} + + bool deserializeBlock(Parser& parser, Parser::name_stack_range_t name_stack_range, bool new_name) + { + derived_t& typed_param = static_cast<derived_t&>(*this); + // try to parse direct value T + if (name_stack_range.first == name_stack_range.second) + { + if(parser.readValue(typed_param.mValue)) { - // try to parse a known named value - std::string name; - if (parser.readValue(name)) - { - // try to parse a per type named value - if (TypeValues<T>::get(name, typed_param.mData.mValue)) - { - typed_param.mData.setKey(name); - typed_param.enclosingBlock().setLastChangedParam(param, true); - typed_param.setProvided(true); - typed_param.mData.mValueAge = NEWER_THAN_BLOCK; - typed_param.setBlockFromValue(); + typed_param.mValueAge = VALUE_AUTHORITATIVE; + typed_param.updateBlockFromValue(false); - return true; - } - } + typed_param.clearValueName(); + + return true; } } // fall back on parsing block components for T - // if we deserialized at least one component... - if (typed_param.BaseBlock::deserializeBlock(parser, name_stack)) - { - // ...our block is provided, and considered changed - typed_param.enclosingBlock().setLastChangedParam(param, true); - typed_param.setProvided(true); - return true; - } - return false; + return typed_param.BaseBlock::deserializeBlock(parser, name_stack_range, new_name); } - static void serializeParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, const Param* diff_param) + void serializeBlock(Parser& parser, Parser::name_stack_t& name_stack, const BaseBlock* diff_block = NULL) const { - const self_t& typed_param = static_cast<const self_t&>(param); + const derived_t& typed_param = static_cast<const derived_t&>(*this); + const derived_t* diff_param = static_cast<const derived_t*>(diff_block); - if (!typed_param.isProvided()) return; - - std::string key = typed_param.mData.getKey(); + std::string key = typed_param.getValueName(); // first try to write out name of name/value pair if (!key.empty()) { - if (!diff_param || !ParamCompare<std::string>::equals(static_cast<const self_t*>(diff_param)->mData.getKey(), key)) + if (!diff_param || !ParamCompare<std::string>::equals(diff_param->getValueName(), key)) { - if (!parser.writeValue(key, name_stack)) - { - return; - } + parser.writeValue(key, name_stack); } } // then try to serialize value directly - else if (!diff_param || !ParamCompare<T>::equals(typed_param.get(), (static_cast<const self_t*>(diff_param))->get())) + else if (!diff_param || !ParamCompare<T>::equals(typed_param.getValue(), diff_param->getValue())) { - if (parser.writeValue(typed_param.mData.mValue, name_stack)) + if (!parser.writeValue(typed_param.getValue(), name_stack)) { - return; + //RN: *always* serialize provided components of BlockValue (don't pass diff_param on), + // since these tend to be viewed as the constructor arguments for the value T. It seems + // cleaner to treat the uniqueness of a BlockValue according to the generated value, and + // not the individual components. This way <color red="0" green="1" blue="0"/> will not + // be exported as <color green="1"/>, since it was probably the intent of the user to + // be specific about the RGB color values. This also fixes an issue where we distinguish + // between rect.left not being provided and rect.left being explicitly set to 0 (same as default) + + if (typed_param.mValueAge == VALUE_AUTHORITATIVE) + { + // if the value is authoritative but the parser doesn't accept the value type + // go ahead and make a copy, and splat the value out to its component params + // and serialize those params + derived_t copy(typed_param); + copy.updateBlockFromValue(true); + copy.block_t::serializeBlock(parser, name_stack, NULL); + } + else + { + block_t::serializeBlock(parser, name_stack, NULL); + } } - - //RN: *always* serialize provided components of BlockValue (don't pass diff_param on), - // since these tend to be viewed as the constructor arguments for the value T. It seems - // cleaner to treat the uniqueness of a BlockValue according to the generated value, and - // not the individual components. This way <color red="0" green="1" blue="0"/> will not - // be exported as <color green="1"/>, since it was probably the intent of the user to - // be specific about the RGB color values. This also fixes an issue where we distinguish - // between rect.left not being provided and rect.left being explicitly set to 0 (same as default) - typed_param.BaseBlock::serializeBlock(parser, name_stack, NULL); } } - static void inspectParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, S32 min_count, S32 max_count) + bool inspectBlock(Parser& parser, Parser::name_stack_t name_stack = Parser::name_stack_t(), S32 min_count = 0, S32 max_count = S32_MAX) const { // first, inspect with actual type... parser.inspectValue<T>(name_stack, min_count, max_count, NULL); @@ -1739,25 +2182,19 @@ namespace LLInitParam parser.inspectValue<std::string>(name_stack, min_count, max_count, TypeValues<T>::getPossibleValues()); } // then recursively inspect contents... - const self_t& typed_param = static_cast<const self_t&>(param); - typed_param.inspectBlock(parser, name_stack); + return block_t::inspectBlock(parser, name_stack, min_count, max_count); } - - bool isProvided() const + bool validateBlock(bool emit_errors = true) const { - if (!Param::anyProvided()) return false; - - // block has an updated parameter - // if cached value is stale, regenerate from params - if (mData.mValueAge == OLDER_THAN_BLOCK) + if (mValueAge == VALUE_NEEDS_UPDATE) { - if (block_t::validateBlock(false)) + if (block_t::validateBlock(emit_errors)) { - static_cast<const DERIVED*>(this)->setValueFromBlock(); // clear stale keyword associated with old value - mData.clearKey(); - mData.mValueAge = SAME_AS_BLOCK; + TypeValues<T>::clearValueName(); + mValueAge = BLOCK_AUTHORITATIVE; + static_cast<derived_t*>(const_cast<self_t*>(this))->updateValueFromBlock(); return true; } else @@ -1774,104 +2211,89 @@ namespace LLInitParam } } - void set(value_assignment_t val, bool flag_as_provided = true) - { - Param::enclosingBlock().setLastChangedParam(*this, flag_as_provided); - - // set param version number to be up to date, so we ignore block contents - mData.mValueAge = NEWER_THAN_BLOCK; - - mData.mValue = val; - mData.clearKey(); - setProvided(flag_as_provided); - static_cast<DERIVED*>(this)->setBlockFromValue(); - } - - void setIfNotProvided(value_assignment_t val, bool flag_as_provided = true) - { - // don't override any user provided value - if (!isProvided()) - { - set(val, flag_as_provided); - } - } - // propagate change status up to enclosing block - /*virtual*/ void setLastChangedParam(const Param& last_param, bool user_provided) + /*virtual*/ void paramChanged(const Param& changed_param, bool user_provided) { - BaseBlock::setLastChangedParam(last_param, user_provided); - Param::enclosingBlock().setLastChangedParam(*this, user_provided); + BaseBlock::paramChanged(changed_param, user_provided); if (user_provided) { - setProvided(true); // some component provided // a parameter changed, so our value is out of date - mData.mValueAge = OLDER_THAN_BLOCK; + mValueAge = VALUE_NEEDS_UPDATE; } } + + void setValue(value_assignment_t val) + { + derived_t& typed_param = static_cast<derived_t&>(*this); + // set param version number to be up to date, so we ignore block contents + mValueAge = VALUE_AUTHORITATIVE; + mValue = val; + typed_param.clearValueName(); + static_cast<derived_t*>(this)->updateBlockFromValue(false); + } - protected: - value_assignment_t get() const + value_assignment_t getValue() const { - // if some parameters were provided, issue warnings on invalid blocks - if (Param::anyProvided() && (mData.mValueAge == OLDER_THAN_BLOCK)) - { - // go ahead and issue warnings at this point if any param is invalid - if(block_t::validateBlock(true)) - { - static_cast<const DERIVED*>(this)->setValueFromBlock(); - mData.clearKey(); - mData.mValueAge = SAME_AS_BLOCK; - } - } + validateBlock(true); + return mValue; + } - return mData.mValue; + T& getValue() + { + validateBlock(true); + return mValue; } + operator value_assignment_t() const + { + return getValue(); + } - struct Data : public key_cache_t + value_assignment_t operator()() const { - Data(const T& value, EValueAge age) - : mValue(value), - mValueAge(age) - {} + return getValue(); + } - T mValue; - EValueAge mValueAge; - }; + protected: - // mutable to allow lazy updates on get - mutable Data mData; + // use this from within updateValueFromBlock() to set the value without making it authoritative + void updateValue(value_assignment_t value) + { + mValue = value; + } - private: - static bool mergeWith(Param& dst, const Param& src, bool overwrite) + bool mergeBlockParam(bool source_provided, bool dst_provided, BlockDescriptor& block_data, const BaseBlock& source, bool overwrite) { - const DERIVED& src_typed_param = static_cast<const DERIVED&>(src); - DERIVED& dst_typed_param = static_cast<DERIVED&>(dst); + bool source_override = source_provided && (overwrite || !dst_provided); - if (src_typed_param.isProvided() - && (overwrite || !dst_typed_param.isProvided())) + const derived_t& src_typed_param = static_cast<const derived_t&>(source); + + if (source_override && src_typed_param.mValueAge == VALUE_AUTHORITATIVE) { - if (src_typed_param.mData.mValueAge == NEWER_THAN_BLOCK) - { - // copy value over - dst_typed_param.set(src_typed_param.get()); - } - else - { - // merge individual parameters into destination - dst_typed_param.merge(block_t::selfBlockDescriptor(), src_typed_param, overwrite); - } + // copy value over + setValue(src_typed_param.getValue()); return true; } - return false; + // merge individual parameters into destination + if (mValueAge == VALUE_AUTHORITATIVE) + { + static_cast<derived_t*>(this)->updateBlockFromValue(dst_provided); + } + return mergeBlock(block_data, source, overwrite); } - }; - template<> - struct ParamCompare<LLSD, false> - { - static bool equals(const LLSD &a, const LLSD &b); + bool mergeBlock(BlockDescriptor& block_data, const BaseBlock& source, bool overwrite) + { + return block_t::mergeBlock(block_data, source, overwrite); + } + + mutable bool mValidated; // lazy validation flag + + private: + mutable T mValue; + mutable EValueAge mValueAge; }; } + #endif // LL_LLPARAM_H |