From de02b5618273df1b94085934f699371b4be31783 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Mon, 3 Sep 2007 08:57:39 +0000 Subject: [PATCH] Handle unknown types as enums Move some functions into loader.cpp Add a LoaderAction for an arbitary number of arguments of the same type Add a LoaderAction to load two values directly into member variables Add an overload of load_sub that takes an extra parameter for the loader --- source/loader.cpp | 49 +++++++++++++ source/loader.h | 180 +++++++++++++++++++++++++++++++++------------- source/value.h | 2 +- 3 files changed, 181 insertions(+), 50 deletions(-) create mode 100644 source/loader.cpp diff --git a/source/loader.cpp b/source/loader.cpp new file mode 100644 index 0000000..cf1a5ac --- /dev/null +++ b/source/loader.cpp @@ -0,0 +1,49 @@ +/* $Id$ + +This file is part of libmspdatafile +Copyright © 2006 Mikko Rasa, Mikkosoft Productions +Distributed under the LGPL +*/ + +#include "loader.h" + +using namespace std; + +namespace Msp { +namespace DataFile { + +void Loader::load(const Statement &st) +{ + for(list::const_iterator i=st.sub.begin(); i!=st.sub.end(); ++i) + load_statement(*i); +} + +void Loader::load(Parser &p) +{ + while(p) + { + Statement st=p.parse(); + if(st.valid) + load_statement(st); + } +} + +Loader::~Loader() +{ + for(ActionMap::iterator i=actions.begin(); i!=actions.end(); ++i) + delete i->second; +} + +void Loader::load_statement(const Statement &st) +{ + cur_st=&st; + ActionMap::iterator j=actions.find(st.keyword); + if(j==actions.end()) + throw KeyError(st.get_location()+": Unknown keyword '"+st.keyword+"'"); + if(j->second) + j->second->execute(*this, st); + cur_st=0; +} + +} // namespace DataFile +} // namespace Msp diff --git a/source/loader.h b/source/loader.h index 48d4f9b..70fb7c2 100644 --- a/source/loader.h +++ b/source/loader.h @@ -4,6 +4,7 @@ This file is part of libmspdatafile Copyright © 2006 Mikko Rasa, Mikkosoft Productions Distributed under the LGPL */ + #ifndef MSP_DATAFILE_LOADER_H_ #define MSP_DATAFILE_LOADER_H_ @@ -20,21 +21,31 @@ namespace DataFile { class Loader; class Statement; +/** +Base class for loader actions. +*/ class LoaderAction { public: + /** + Called when a statement is to be loaded. + */ virtual void execute(Loader &, const Statement &) const=0; virtual ~LoaderAction() { } protected: LoaderAction() { } }; + +/** +Loads a statement by calling a function that takes no arguments. +*/ template class LoaderFunc0: public LoaderAction { public: typedef void (L::*FuncType)(); - + LoaderFunc0(FuncType f): func(f) { } void execute(Loader &l, const Statement &st) const { @@ -45,12 +56,16 @@ private: FuncType func; }; + +/** +Loads a statement by calling a function that takes one argument. +*/ template class LoaderFunc1: public LoaderAction { public: typedef void (L::*FuncType)(A0); - + LoaderFunc1(FuncType f): func(f) { } void execute(Loader &l, const Statement &st) const { @@ -61,12 +76,36 @@ private: FuncType func; }; + +/** +Loads a statement by calling a function that takes an array of values. +*/ +template +class LoaderFunc1 &>: public LoaderAction +{ +public: + typedef void (L::*FuncType)(const std::list &); + + LoaderFunc1(FuncType f): func(f) { } + void execute(Loader &l, const Statement &st) const + { + std::vector values; + values.reserve(st.args.size()); + for(ValueArray::iterator i=st.args.begin(); i!=st.args.end(); ++i) + values.push_back(i->get()); + (dynamic_cast(l).*func)(values); + } +private: + FuncType func; +}; + + template class LoaderFunc2: public LoaderAction { public: typedef void (L::*FuncType)(A0, A1); - + LoaderFunc2(FuncType f): func(f) { } void execute(Loader &l, const Statement &st) const { @@ -77,12 +116,13 @@ private: FuncType func; }; + template class LoaderFunc3: public LoaderAction { public: typedef void (L::*FuncType)(A0, A1, A2); - + LoaderFunc3(FuncType f): func(f) { } void execute(Loader &l, const Statement &st) const { @@ -93,12 +133,13 @@ private: FuncType func; }; + template class LoaderFunc4: public LoaderAction { public: typedef void (L::*FuncType)(A0, A1, A2, A3); - + LoaderFunc4(FuncType f): func(f) { } void execute(Loader &l, const Statement &st) const { @@ -109,104 +150,145 @@ private: FuncType func; }; -template -class LoadValue: public LoaderAction + +template +class LoadValue1: public LoaderAction { public: - typedef T L::*PointerType; - - LoadValue(PointerType p): ptr(p) { } + typedef T0 L::*Pointer0Type; + + LoadValue1(Pointer0Type p0): ptr0(p0) { } void execute(Loader &l, const Statement &st) const { if(st.args.size()!=1) throw TypeError(st.get_location()+": Wrong number of arguments"); - dynamic_cast(l).get_object().*ptr=st.args[0].get(); + dynamic_cast(l).get_object().*ptr0=st.args[0].get(); } private: - PointerType ptr; + Pointer0Type ptr0; }; -class Loader + +template +class LoadValue2: public LoaderAction { public: - void load(const Statement &st) - { - for(std::list::const_iterator i=st.sub.begin(); i!=st.sub.end(); ++i) - load_statement(*i); - } - void load(Parser &p) - { - while(p) - { - Statement st=p.parse(); - if(st.valid) - load_statement(st); - } - } - virtual ~Loader() + typedef T0 L::*Pointer0Type; + typedef T1 L::*Pointer1Type; + + LoadValue2(Pointer0Type p0, Pointer1Type p1): ptr0(p0), ptr1(p1) { } + void execute(Loader &l, const Statement &st) const { - for(ActionMap::iterator i=actions.begin(); i!=actions.end(); ++i) - delete i->second; + if(st.args.size()!=2) throw TypeError(st.get_location()+": Wrong number of arguments"); + dynamic_cast(l).get_object().*ptr0=st.args[0].get(); + dynamic_cast(l).get_object().*ptr1=st.args[1].get(); } +private: + Pointer0Type ptr0; + Pointer1Type ptr1; +}; + + +/** +Base class for data loaders. To enable objects of a certain class to be loaded +from datafiles, create a public Loader class in it, derived from this class. +Typically the Loader class contains a reference to the object being loaded. If +you want to load data members of the object directly, the Loader class must +have a member function get_object() returning that reference. +*/ +class Loader +{ +public: + /** + Loads data from a statement. This is normally only used by the Loader class + itself for loading sub-items, but needs to be public so it can be accessed + in derived objects. + */ + void load(const Statement &st); + + /** + Loads statements from a parser. + */ + void load(Parser &p); + + virtual ~Loader(); protected: Loader(): cur_st(0) { } - + template void add(const std::string &k, void (L::*func)()) { actions.insert(typename ActionMap::value_type(k, new LoaderFunc0(func))); } - + template void add(const std::string &k, void (L::*func)(A0)) { actions.insert(typename ActionMap::value_type(k, new LoaderFunc1(func))); } - + template void add(const std::string &k, void (L::*func)(A0, A1)) { actions.insert(typename ActionMap::value_type(k, new LoaderFunc2(func))); } - + template void add(const std::string &k, void (L::*func)(A0, A1, A2)) { actions.insert(typename ActionMap::value_type(k, new LoaderFunc3(func))); } - + template void add(const std::string &k, void (L::*func)(A0, A1, A2, A3)) { actions.insert(typename ActionMap::value_type(k, new LoaderFunc4(func))); } - template - void add(const std::string &k, T L::*p) - { actions.insert(typename ActionMap::value_type(k, new LoadValue(p))); } + template + void add(const std::string &k, T0 L::*p0) + { actions.insert(typename ActionMap::value_type(k, new LoadValue1(p0))); } + + template + void add(const std::string &k, T0 L::*p0, T1 L::*p1) + { actions.insert(typename ActionMap::value_type(k, new LoadValue2(p0, p1))); } void add(const std::string &k) { actions.insert(ActionMap::value_type(k, 0)); } + /** + Loads a sub-object from the statement being currently processed. The Loader + class of the sub-object is automatically used. + */ template void load_sub(S &s) { load_sub(s); } + /** + Loads a sub-object with a custom Loader class. + */ template void load_sub(S &s) { if(!cur_st) - throw Exception("load_sub called without current statement"); + throw InvalidState("load_sub called without current statement"); L loader(s); loader.load(*cur_st); } + + /** + Loads a sub-object with a custom Loader class that takes one argument in + addition to to object to be loaded. + */ + template + void load_sub(S &s, T &p) + { + if(!cur_st) + throw InvalidState("load_sub called without current statement"); + L loader(s, p); + loader.load(*cur_st); + } private: typedef std::map ActionMap; ActionMap actions; const Statement *cur_st; - void load_statement(const Statement &st) - { - cur_st=&st; - ActionMap::iterator j=actions.find(st.keyword); - if(j==actions.end()) - throw Exception(st.get_location()+": Unknown keyword '"+st.keyword+"'"); - if(j->second) - j->second->execute(*this, st); - cur_st=0; - } + void load_statement(const Statement &st); }; +/** +Loads an object from a file. The object must have a public Loader class. +*/ template void load(T &obj, const std::string &fn) { diff --git a/source/value.h b/source/value.h index 5ebbb5e..f809c8f 100644 --- a/source/value.h +++ b/source/value.h @@ -36,7 +36,7 @@ private: }; typedef std::vector ValueArray; -template struct TypeResolver { }; +template struct TypeResolver { static const Value::Type type=Value::ENUM; }; template<> struct TypeResolver { static const Value::Type type=Value::INTEGER; }; template<> struct TypeResolver { static const Value::Type type=Value::INTEGER; }; -- 2.43.0