llinitparam.h

/** 
 * @file llinitparam.h
 * @brief parameter block abstraction for creating complex objects and 
 * parsing construction parameters from xml and LLSD
 *
 * $LicenseInfo:firstyear=2008&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_LLPARAM_H
#define LL_LLPARAM_H

#include <vector>
#include <boost/function.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/unordered_map.hpp>
#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 
	{
    	static bool equals(const T &a, const T &b)
		{
			return a == b;
		}
    };
    
	// boost function types are not comparable
	template<typename T>
	struct ParamCompare<T, true>
	{
		static bool equals(const T&a, const T &b)
		{
			return false;
		}
	};

	template<> 
	struct ParamCompare<LLSD, false>
	{
		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
	{
	public:
		typedef std::map<std::string, T> value_name_map_t;

		void setValueName(const std::string& key) {}
		std::string getValueName() const { return ""; }
		void clearValueName() const {}

		static bool getValueFromName(const std::string& name, T& value)
		{
			return false;
		}

		static bool valueNamesExist()
		{
			return false;
		}

		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:
		typedef typename std::map<std::string, T> value_name_map_t;

		//TODO: cache key by index to save on param block size
		void setValueName(const std::string& value_name) 
		{
			mValueName = value_name; 
		}

		std::string getValueName() const
		{ 
			return mValueName; 
		}

		void clearValueName() const
		{
			mValueName.clear();
		}

		static bool getValueFromName(const std::string& name, T& value)
		{
			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 = found_it->second;
			return true;
		}

		static bool valueNamesExist()
		{
			return !getValueNames()->empty();
		}
	
		static value_name_map_t* getValueNames()
		{
			static value_name_map_t sMap;
			static bool sInitialized = false;

			if (!sInitialized)
			{
				sInitialized = true;
				DERIVED_TYPE::declareValues();
			}
			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;
		}

		static void declare(const std::string& name, const T& value)
		{
			(*getValueNames())[name] = value;
		}

	protected:
		static void getName(const std::string& name, const T& value)
		{}

		mutable std::string	mValueName;
	};

	class Parser
	{
		LOG_CLASS(Parser);

	public:
		
		struct CompareTypeID
		{
			bool operator()(const std::type_info* lhs, const std::type_info* rhs) const
			{
				return lhs->before(*rhs);
			}
		};

		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 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 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;
		typedef std::map<const std::type_info*, parser_inspect_func_t, CompareTypeID>	parser_inspect_func_map_t;

		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(sNextParseGeneration),
			mParserReadFuncs(&read_map),
			mParserWriteFuncs(&write_map),
			mParserInspectFuncs(&inspect_map)
		{}
		virtual ~Parser();

		template <typename T> bool readValue(T& param)
	    {
		    parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(&typeid(T));
		    if (found_it != mParserReadFuncs->end())
		    {
			    return found_it->second(*this, (void*)&param);
		    }
		    return false;
	    }

		template <typename T> bool writeValue(const T& param, const name_stack_t& name_stack)
		{
		    parser_write_func_map_t::iterator found_it = mParserWriteFuncs->find(&typeid(T));
		    if (found_it != mParserWriteFuncs->end())
		    {
			    return found_it->second(*this, (const void*)&param, name_stack);
		    }
		    return false;
		}

		// 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)
		{
		    parser_inspect_func_map_t::iterator found_it = mParserInspectFuncs->find(&typeid(T));
		    if (found_it != mParserInspectFuncs->end())
		    {
			    found_it->second(name_stack, min_count, max_count, possible_values);
				return true;
		    }
			return false;
		}

		virtual std::string getCurrentElementName() = 0;
		virtual void parserWarning(const std::string& message);
		virtual void parserError(const std::string& message);
		void setParseSilently(bool silent) { mParseSilently = silent; }

		S32 getParseGeneration() { return mParseGeneration; }
		S32 newParseGeneration() { return mParseGeneration = ++sNextParseGeneration; }


	protected:
		template <typename T>
		void registerParserFuncs(parser_read_func_t read_func, parser_write_func_t write_func = NULL)
		{
			mParserReadFuncs->insert(std::make_pair(&typeid(T), read_func));
			mParserWriteFuncs->insert(std::make_pair(&typeid(T), write_func));
		}

		template <typename T>
		void registerInspectFunc(parser_inspect_func_t inspect_func)
		{
			mParserInspectFuncs->insert(std::make_pair(&typeid(T), inspect_func));
		}

		bool				mParseSilently;

	private:
		parser_read_func_map_t*		mParserReadFuncs;
		parser_write_func_map_t*	mParserWriteFuncs;
		parser_inspect_func_map_t*	mParserInspectFuncs;
		S32	mParseGeneration;

		static S32					sNextParseGeneration;
	};

	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;

	};

	// various callbacks and constraints associated with an individual param
	struct ParamDescriptor
	{
		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 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);

		ParamDescriptor();
		~ParamDescriptor();

		param_handle_t		mParamHandle;
		merge_func_t		mMergeFunc;
		deserialize_func_t	mDeserializeFunc;
		serialize_func_t	mSerializeFunc;
		inspect_func_t		mInspectFunc;
		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();

		typedef enum e_initialization_state
		{
			UNINITIALIZED,
			INITIALIZING,
			INITIALIZED
		} EInitializationState;

		void aggregateBlockData(BlockDescriptor& src_block_data);

		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
		BaseBlock*						mCurrentBlockPtr;		// pointer to block currently being constructed
	};

	class BaseBlock
	{
	public:
		// "Multiple" constraint types, put here in root class to avoid ambiguity during use
		struct AnyAmount
		{
			enum { minCount = 0 };
			enum { maxCount = U32_MAX };
		};

		template<U32 MIN_AMOUNT>
		struct AtLeast
		{
			enum { minCount = MIN_AMOUNT };
			enum { maxCount = U32_MAX };
		};

		template<U32 MAX_AMOUNT>
		struct AtMost
		{
			enum { minCount = 0 };
			enum { maxCount = MAX_AMOUNT };
		};

		template<U32 MIN_AMOUNT, U32 MAX_AMOUNT>
		struct Between
		{
			enum { minCount = MIN_AMOUNT };
			enum { maxCount = MAX_AMOUNT };
		};

		template<U32 EXACT_COUNT>
		struct Exactly
		{
			enum { minCount = EXACT_COUNT };
			enum { maxCount = EXACT_COUNT };
		};

		// this typedef identifies derived classes as being blocks
		typedef void baseblock_base_class_t;
		LOG_CLASS(BaseBlock);
		friend class Param;

		BaseBlock();
		virtual ~BaseBlock();
		bool submitValue(const 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;

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

		const Param* getParamFromHandle(const param_handle_t param_handle) const
		{
			const U8* baseblock_address = reinterpret_cast<const U8*>(this);
			return reinterpret_cast<const Param*>(baseblock_address + param_handle);
		}

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

		bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack, S32 generation);
		void 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(), S32 min_count = 0, S32 max_count = S32_MAX) const;

		virtual const BlockDescriptor& mostDerivedBlockDescriptor() const { return selfBlockDescriptor(); }
		virtual BlockDescriptor& mostDerivedBlockDescriptor() { return selfBlockDescriptor(); }

		// take all provided params from other and apply to self
		bool overwriteFrom(const BaseBlock& other)
		{
			return false;
		}

		// take all provided params that are not already provided, and apply to self
		bool fillFrom(const BaseBlock& other)
		{
			return false;
		}

		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 mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite);

		// can be updated in getters
		mutable S32				mChangeVersion;

		static BlockDescriptor& selfBlockDescriptor()
		{
			static BlockDescriptor sBlockDescriptor;
			return sBlockDescriptor;
		}

	private:
		const std::string& getParamName(const BlockDescriptor& block_data, const Param* paramp) const;
	};

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

	template<typename T>
	struct IsBlock<T, typename T::baseblock_base_class_t>
	{
		static const bool value = true;
	};

	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;

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


	private:
		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;

		ParamValue() 
		:	T(),
			mKeyVersion(0),
			mValidatedVersion(-1),
			mValidated(false)
		{}

		ParamValue(value_assignment_t other)
		:	T(other),
			mKeyVersion(0),
			mValidatedVersion(-1),
			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;
		}

		S32 			mKeyVersion;

	protected:
		mutable S32 	mValidatedVersion;
		mutable bool 	mValidated; // lazy validation flag
	};

	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
	// e.g. TypedParam<LLRect> has left, top, right, bottom, etc...
	template<typename	T,
			typename	NAME_VALUE_LOOKUP = TypeValues<T>,
			bool		HAS_MULTIPLE_VALUES = false,
			bool		VALUE_IS_BLOCK = IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::value>
	class TypedParam 
	:	public Param, 
		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;

		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))
			{
 				ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor(
												block_descriptor.mCurrentBlockPtr->getHandleFromParam(this),
												&mergeWith,
												&deserializeParam,
												&serializeParam,
												validate_func,
												&inspectParam,
												min_count, max_count));
				BaseBlock::addParam(block_descriptor, param_descriptor, name);
			}

			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) 
		{ 
			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 (parser.readValue(typed_param.getValue()))
				{
					typed_param.clearValueName();
					typed_param.setProvided(true);
					typed_param.enclosingBlock().paramChanged(param, true);
					return true;
				}
				
				// try to parse a known named value
				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_t::getValueFromName(name, typed_param.getValue()))
						{
							typed_param.setValueName(name);
							typed_param.setProvided(true);
							typed_param.enclosingBlock().paramChanged(param, true);
							return true;
						}

					}
				}
			}
			return false;
		}

		static void serializeParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, const Param* diff_param)
		{
			const self_t& typed_param = static_cast<const self_t&>(param);
			if (!typed_param.isProvided()) return;

			if (!name_stack.empty())
			{
				name_stack.back().second = parser.newParseGeneration();
			}

			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)->getValueName(), key))
				{
					if (!parser.writeValue(key, name_stack))
					{
						return;
					}
				}
			}
			// then try to serialize value directly
			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;
				}
			}
		}

		static void inspectParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, S32 min_count, S32 max_count)
		{
			// tell parser about our actual type
			parser.inspectValue<T>(name_stack, min_count, max_count, NULL);
			// then tell it about string-based alternatives ("red", "blue", etc. for LLColor4)
			if (name_value_lookup_t::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)
		{
			setValue(val);
			param_value_t::clearValueName();
			setProvided(flag_as_provided);
			Param::enclosingBlock().paramChanged(*this, flag_as_provided);
		}

	protected:

		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.set(src_typed_param.getValue());
				return true;
			}
			return false;
		}
	};

	// parameter that is a block
	template <typename T, typename NAME_VALUE_LOOKUP>
	class TypedParam<T, NAME_VALUE_LOOKUP, false, true> 
	:	public Param,
		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 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;

		TypedParam(BlockDescriptor& block_descriptor, const char* name, value_assignment_t value, ParamDescriptor::validation_func_t validate_func, S32 min_count, S32 max_count)
		:	Param(block_descriptor.mCurrentBlockPtr),
			param_value_t(value)
		{
			if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING))
			{
				ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor(
												block_descriptor.mCurrentBlockPtr->getHandleFromParam(this),
												&mergeWith,
												&deserializeParam,
												&serializeParam,
												validate_func, 
												&inspectParam,
												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) 
		{ 
			self_t& typed_param = static_cast<self_t&>(param);
			// attempt to parse block...
			if(typed_param.deserializeBlock(parser, name_stack, generation))
			{
				typed_param.clearValueName();
				typed_param.enclosingBlock().paramChanged(param, true);
				typed_param.setProvided(true);
				return true;
			}

			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_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();
						return true;
					}

				}
			}
			return false;
		}

		static void serializeParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, const Param* diff_param)
		{
			const self_t& typed_param = static_cast<const self_t&>(param);
			if (!typed_param.isProvided()) return;

			if (!name_stack.empty())
			{
				name_stack.back().second = parser.newParseGeneration();
			}

			std::string key = typed_param.getValueName();
			if (!key.empty() && typed_param.mKeyVersion == typed_param.getLastChangeVersion())
			{
				if (!parser.writeValue(key, name_stack))
				{
					return;
				}
			}
			else
			{
				typed_param.serializeBlock(parser, name_stack, static_cast<const self_t*>(diff_param));
			}
		}

		static void inspectParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, S32 min_count, S32 max_count)
		{
			// 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, 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 with current data
			if (Param::anyProvided() && param_value_t::mValidatedVersion < param_value_t::getLastChangeVersion())
			{
				// 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;
		}

		// assign block contents to this param-that-is-a-block
		void set(value_assignment_t val, bool flag_as_provided = true)
		{
			setValue(val);
			param_value_t::clearValueName();
			// force revalidation of block by clearing known provided version
			// next call to isProvided() will update provision status based on validity
			param_value_t::mValidatedVersion = -1;
			setProvided(flag_as_provided);
			Param::enclosingBlock().paramChanged(*this, flag_as_provided);
		}

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

	protected:

		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.anyProvided())
			{
				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);
					dst_typed_param.enclosingBlock().paramChanged(dst_typed_param, true);
					return true;
				}
			}
			return false;
		}
	};

	// container of non-block parameters
	template <typename VALUE_TYPE, typename NAME_VALUE_LOOKUP>
	class TypedParam<VALUE_TYPE, NAME_VALUE_LOOKUP, true, false> 
	:	public Param
	{
	public:
		typedef TypedParam<VALUE_TYPE, NAME_VALUE_LOOKUP, true, false>		self_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 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)
		{
			std::copy(value.begin(), value.end(), std::back_inserter(mValues));

			if (LL_UNLIKELY(block_descriptor.mInitializationState == BlockDescriptor::INITIALIZING))
			{
				ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor(
												block_descriptor.mCurrentBlockPtr->getHandleFromParam(this),
												&mergeWith,
												&deserializeParam,
												&serializeParam,
												validate_func,
												&inspectParam,
												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) 
		{ 
			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)
			{
				// attempt to read value directly
				if (parser.readValue(value))
				{
					typed_param.add(value);
					return true;
				}
				
				// try to parse a known named value
				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_t::getValueFromName(name, typed_param.mValues))
						{
							typed_param.add(value);
							typed_param.mValues.back().setValueName(name);
							return true;
						}

					}
				}
			}
			return false;
		}

		static void serializeParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, const Param* diff_param)
		{
			const self_t& typed_param = static_cast<const self_t&>(param);
			if (!typed_param.isProvided() || name_stack.empty()) return;

			for (const_iterator it = typed_param.mValues.begin(), end_it = typed_param.mValues.end();
				it != end_it;
				++it)
			{
				std::string key = it->getValue();
				name_stack.back().second = parser.newParseGeneration();