livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed build

meow-7.2.2
Richard Linden 2011-10-27 19:31:11 -07:00
parent 5c6de23e03
commit f84a69a7e0
2 changed files with 4 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
indra/llui/lluictrlfactory.h
View File

@ -125,12 +125,12 @@ private:
// base case for recursion, there are NO base classes of LLInitParam::BaseBlock
template<int DUMMY>
class ParamDefaults<LLInitParam::BaseBlockWithFlags, DUMMY> : public LLSingleton<ParamDefaults<LLInitParam::BaseBlockWithFlags, DUMMY> >
class ParamDefaults<LLInitParam::BaseBlock, DUMMY> : public LLSingleton<ParamDefaults<LLInitParam::BaseBlock, DUMMY> >
{
public:
const LLInitParam::BaseBlockWithFlags& get() { return mBaseBlock; }
const LLInitParam::BaseBlock& get() { return mBaseBlock; }
private:
LLInitParam::BaseBlockWithFlags mBaseBlock;
LLInitParam::BaseBlock mBaseBlock;
};
public:

95
indra/llxuixml/llinitparam.h
View File

@ -511,92 +511,6 @@ namespace LLInitParam
const std::string& getParamName(const BlockDescriptor& block_data, const Param* paramp) const;
};
class BaseBlockWithFlags : public BaseBlock
{
public:
class FlagBase : public Param
{
public:
typedef FlagBase self_t;
FlagBase(const char* name, BaseBlock* enclosing_block) : Param(enclosing_block)
{
if (LL_UNLIKELY(enclosing_block->mostDerivedBlockDescriptor().mInitializationState == BlockDescriptor::INITIALIZING))
{
ParamDescriptorPtr param_descriptor = ParamDescriptorPtr(new ParamDescriptor(
enclosing_block->getHandleFromParam(this),
&mergeWith,
&deserializeParam,
&serializeParam,
NULL,
&inspectParam,
0, 1));
BaseBlock::addParam(enclosing_block->mostDerivedBlockDescriptor(), param_descriptor, name);
}
}
bool isProvided() const { return anyProvided(); }
private:
static bool mergeWith(Param& dst, const Param& src, bool overwrite)
{
const self_t& src_typed_param = static_cast<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.setProvided(true);
return true;
}
return false;
}
static bool deserializeParam(Param& param, Parser& parser, const Parser::name_stack_range_t& name_stack, S32 generation)
{
self_t& typed_param = static_cast<self_t&>(param);
// no further names in stack, parse value now
if (name_stack.first == name_stack.second)
{
typed_param.setProvided(true);
typed_param.enclosingBlock().paramChanged(param, true);
return true;
}
return false;
}
static void serializeParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, const Param* diff_param)
{
const self_t& typed_param = static_cast<const self_t&>(param);
const self_t* typed_diff_param = static_cast<const self_t*>(diff_param);
if (!typed_param.isProvided()) return;
if (!name_stack.empty())
{
name_stack.back().second = parser.newParseGeneration();
}
// then try to serialize value directly
if (!typed_diff_param || !typed_diff_param->isProvided())
{
if (!parser.writeValue(NoParamValue(), name_stack))
{
return;
}
}
}
static void inspectParam(const Param& param, Parser& parser, Parser::name_stack_t& name_stack, S32 min_count, S32 max_count)
{
// tell parser about our actual type
parser.inspectValue<NoParamValue>(name_stack, min_count, max_count, NULL);
}
};
};
// these templates allow us to distinguish between template parameters
// that derive from BaseBlock and those that don't
template<typename T, typename Void = void>
@ -1537,7 +1451,7 @@ namespace LLInitParam
}
};
template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlockWithFlags>
template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlock>
class Block
: public BASE_BLOCK
{
@ -1633,13 +1547,6 @@ namespace LLInitParam
};
class Flag : public BaseBlockWithFlags::FlagBase
{
public:
Flag(const char* name) : FlagBase(name, DERIVED_BLOCK::selfBlockDescriptor().mCurrentBlockPtr)
{}
};
template <typename T, typename RANGE = BaseBlock::AnyAmount, typename NAME_VALUE_LOOKUP = TypeValues<T> >
class Multiple : public TypedParam<T, NAME_VALUE_LOOKUP, true>
{