Loading in properties of various types
Hi guys,
I'm trying to solve the problem of loading in a lot of properties of
various different (potentially complex) types from file in a reasonable
way, and would really appreciate any advice please.
(I apologise in advance for the length of this post - it seems necessary
to explain the problem in this instance.)
################
Current Approach
################
The way I'm going about it at present, I have types stored against
property names in an XML settings file, e.g.
<property name="Consumables" type="(string -> int)"/>
<property name="Objects" type="[int]"/>
(In this instance, string -> int essentially corresponds to
std::map<std::string,int>, and [int] corresponds to std::vector<int>, in
case that becomes relevant.)
Values are stored in the files I'm trying to load in, e.g.
Consumbles = <("wibble",23);("blah",9)>
Objects = [7,8,51]
To make life simpler, I've made Bison-generated parsers for types and
values.
The type parser is essentially there to transform things like "(string
-> int)" into "string int map" (in post-order). So (for a more complex
example) "(float,(double -> [int]))" would become "float double int
array map pair". From there, I've essentially written a shift-reduce
style parser using template metaprogramming to convert the string into a
type and thereby choose an appropriate function to load in the value
(this is where the problems with my approach would seem to lie: more later).
The value parser converts things like <("wibble",23);("blah",9)> into
things which are easier to parse later on. In particular, the above gets
converted into "<34> <13> <6> wibble 23 <10> <4> blah 9". The numbers in
<> indicate the length of the thing being parsed, if it's not already
obvious (it is for things like ints, since you can just scan for the
next space). Thus "<6> wibble" is easy to parse as a string of length 6,
and "<10> <4> blah 9" is easy to parse as a (string,int) pair, etc.
So at the moment, I write something like:
template <typename T>
struct Storer
{
static void store(const std::string& s, any& a)
{
std::string input = s;
a = PropReader<T>::read(input);
}
};
typedef void StoreFunc(const std::string&,any&);
template <typename T>
struct StorerReturner
{
static boost::function<StoreFunc> func()
{
return Storer<T>::store;
}
};
//...
std::string type = proplib::parse_type("(float,(string,int))");
function<StoreFunc> f =
proplib::select_function<StorerReturner,StoreFunc>(type);
any a;
f(proplib::parse_value("(9,(\"wibble\",23))"), a);
###########
The Problem
###########
This almost seems fair enough, except that in order to convert from the
post-order type strings to the appropriate boost::function, I have to do
some fairly dubious template stuff. Consider (ignoring the throw 23
stuff, which is just there as a placeholder for a proper exception type
while I'm testing the idea):
struct NullType;
template <typename T, typename TS> struct TypeStack;
template <typename T> struct Top;
template <typename t, typename ts> struct Top<TypeStack<t,ts> >
{
typedef t result;
};
template <typename T> struct Rest;
template <typename t, typename ts> struct Rest<TypeStack<t,ts> >
{
typedef ts result;
};
// Note: N is a limit on the template recursion depth - it's crucial or
the compilation will never terminate.
template <typename T, template <typename> class C, typename F, int N>
struct FunctionSelector;
template <typename t, template <typename> class C, typename F>
struct FunctionSelector<TypeStack<t,NullType>, C, F, 0>
{
static boost::function<F> select(const std::string& sig)
{
if(sig == "") return C<t>::func();
else /* FIXME */ throw 23;
}
};
template <typename t, typename ts, template <typename> class C, typename F>
struct FunctionSelector<TypeStack<t,ts>, C, F, 0>
{
static boost::function<F> select(const std::string&)
{
/* FIXME */ throw 23;
}
};
template <template <typename> class C, typename F, int N>
struct FunctionSelector<NullType, C, F, N>
{
static boost::function<F> select(const std::string& sig)
{
if(sig == "") /* FIXME */ throw 23;
size_t i = sig.find_first_of(' ');
std::string type = sig.substr(0, i);
std::string remainder = i != std::string::npos ? sig.substr(i+1) : "";
if(type == "double")
{
return FunctionSelector<TypeStack<double,NullType>, C, F,
N-1>::select(remainder);
}
// etc.
else /* FIXME */ throw 23;
}
};
template <typename t, template <typename> class C, typename F, int N>
struct FunctionSelector<TypeStack<t,NullType>, C, F, N>
{
static boost::function<F> select(const std::string& sig)
{
if(sig == "") return C<t>::func();
size_t i = sig.find_first_of(' ');
std::string type = sig.substr(0, i);
std::string remainder = i != std::string::npos ? sig.substr(i+1) : "";
if(type == "double")
{
return FunctionSelector<TypeStack<double,TypeStack<t,NullType> >,
C, F, N-1>::select(remainder);
}
// etc.
else /* FIXME */ throw 23;
}
};
template <typename t, typename ts, template <typename> class C, typename
F, int N>
struct FunctionSelector<TypeStack<t,ts>, C, F, N>
{
static boost::function<F> select(const std::string& sig)
{
if(sig == "") /* FIXME */ throw 23;
size_t i = sig.find_first_of(' ');
std::string type = sig.substr(0, i);
std::string remainder = i != std::string::npos ? sig.substr(i+1) : "";
if(type == "double")
{
return FunctionSelector<TypeStack<double,TypeStack<t,ts> >, C, F,
N-1>::select(remainder);
}
// etc.
else if(type == "pair")
{
typedef typename Top<ts>::result First;
typedef typename Rest<ts>::result Others;
return FunctionSelector<TypeStack<std::pair<First,t>, Others>, C,
F, N-1>::select(remainder);
}
else /* FIXME */ throw 23;
}
};
template <template <typename> class C, typename F>
boost::function<F> select_function(const std::string& sig)
{
static const int LIMIT = 5;
return FunctionSelector<NullType, C, F, LIMIT>::select(sig);
}
###
This seems nasty for two reasons:
(1) I'm having to limit the number of tokens in the type string in order
to get it to compile (in other words, I can have things like "float int
map string pair", etc., but the number of tokens must have some finite
limit, and that limit is related to the length of the compile time in a
decidedly non-linear way). The compiler's essentially having to
instantiate all possibilities up to that number of tokens, which makes
it noticeably slow to compile. Furthermore, every time I add a new type,
the compile times get significantly worse (which I guess you'd expect -
there would seem to be a combinatorial explosion of some sort going on).
(2) There's a lot of repetition right now (probably the more minor issue
to fix).
###
So: I guess what I'm asking is, is there a better way to do this without
reverting to the "old standby" of registering functions against specific
types and making do with that? (For instance, I could register a
function for loading in things of type "(string -> int)", and one for
loading in things of type "(double -> Vector3d)", etc.) I get the
feeling I'm massively overcomplicating what should be a simple problem
here...
Any suggestions much appreciated!
Best wishes,
Stu