X-Git-Url: http://git.tdb.fi/?p=libs%2Fdatafile.git;a=blobdiff_plain;f=source%2Floader.h;h=fe928048508d208aafe339def238a4cdc722dc2d;hp=5e8b2dfe0a1a5accfa94669ddd1fee5625fae3c1;hb=1a3b30ea35fbc19e56bbd35e4ee1811d8d5e02a4;hpb=5453824394771ca21de32088a2842486b63e6f6d diff --git a/source/loader.h b/source/loader.h index 5e8b2df..fe92804 100644 --- a/source/loader.h +++ b/source/loader.h @@ -1,240 +1,178 @@ -/* -This file is part of libmspparser -Copyright © 2006 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ -#ifndef MSP_PARSER_LOADER_H_ -#define MSP_PARSER_LOADER_H_ +#ifndef MSP_DATAFILE_LOADER_H_ +#define MSP_DATAFILE_LOADER_H_ #include -#include +#include +#include "loaderaction.h" #include "parser.h" #include "statement.h" -#include "value.h" namespace Msp { -namespace Parser { +namespace DataFile { -class Statement; +/** +Base class for data loaders. This class only provides core functionality. +You'll almost certainly want to use one of the BasicLoader classes instead. -template -class LoaderAction -{ -public: - virtual void execute(L &, const Statement &) const=0; - virtual ~LoaderAction() { } -protected: - LoaderAction() { } -}; +Under normal circumstances, a class capable of being loaded should have a +nested typed called Loader which resolves to a descendant of this class. If +another structure is used, the loader object must be constructed manually. -template -class LoaderFunc0: public LoaderAction -{ -public: - typedef void (L::*FuncType)(); - - LoaderFunc0(FuncType f): func(f) { } - void execute(L &l, const Statement &st) const - { - if(st.args.size()!=0) throw TypeError("Wrong number of arguments"); - (l.*func)(); - }; -private: - FuncType func; -}; +A loader class should execute one or more calls to the various add() functions +to register actions with expected keywords. Currently possible actions are +calling a function of the loader, storing values in member variables of an +object and ignoring the statement. If a unexpected keyword is encountered, an +exception is thrown and the loading is aborted. -template -class LoaderFunc1: public LoaderAction -{ -public: - typedef void (L::*FuncType)(A0); - - LoaderFunc1(FuncType f): func(f) { } - void execute(L &l, const Statement &st) const - { - if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); - (l.*func)(st.args[0].get()); - } -private: - FuncType func; -}; +A sub-object can be loaded with one of the load_sub functions. -template -class LoaderFunc2: public LoaderAction -{ -public: - typedef void (L::*FuncType)(A0, A1); - - LoaderFunc2(FuncType f): func(f) { } - void execute(L &l, const Statement &st) const - { - if(st.args.size()!=2) throw TypeError("Wrong number of arguments"); - (l.*func)(st.args[0].get(), st.args[1].get()); - } -private: - FuncType func; -}; +When loading has finished successfully, the virtual function finish() is +called. Any post-processing of the data should be placed here and not in the +destructor. -template -class LoaderFunc3: public LoaderAction +See also classes ObjectLoader and CollectionObjectLoader in objectloader.h. +*/ +class Loader { -public: - typedef void (L::*FuncType)(A0, A1, A2); - - LoaderFunc3(FuncType f): func(f) { } - void execute(L &l, const Statement &st) const - { - if(st.args.size()!=3) throw TypeError("Wrong number of arguments"); - (l.*func)(st.args[0].get(), st.args[1].get(), st.args[2].get()); - } private: - FuncType func; -}; + typedef std::map ActionMap; -template -class LoaderFunc4: public LoaderAction -{ -public: - typedef void (L::*FuncType)(A0, A1, A2, A3); - - LoaderFunc4(FuncType f): func(f) { } - void execute(L &l, const Statement &st) const - { - if(st.args.size()!=4) throw TypeError("Wrong number of arguments"); - (l.*func)(st.args[0].get(), st.args[1].get(), st.args[2].get(), st.args[3].get()); - } -private: - FuncType func; -}; + ActionMap actions; + Parser *cur_parser; + unsigned cur_level; + const Statement *cur_st; + bool sub_loaded; + bool direct; + std::list aux_loaders; +protected: + bool check_sub_loads; -template -class LoadValue: public LoaderAction -{ + Loader(); public: - typedef T L::ObjectType::*PointerType; - - LoadValue(PointerType p): ptr(p) { } - void execute(L &l, const Statement &st) const - { - if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); - l.get_object().*ptr=st.args[0].get(); - } -private: - PointerType ptr; -}; + virtual ~Loader(); -template -class SubLoader0: public LoaderAction -{ -public: - typedef typename S::ObjectType &(L::*FuncType)(); + /** Loads statements from a parser. */ + void load(Parser &p); - SubLoader0(FuncType f): func(f) { } - void execute(L &l, const Statement &st) const - { - if(st.args.size()!=0) throw TypeError("Wrong number of arguments"); - typename S::ObjectType &obj=(l.*func)(); - S sl(obj); - sl.load(st); - } private: - FuncType func; -}; + /** Loads data from a statement. */ + void load(const Statement &st); -template -class SubLoader1: public LoaderAction -{ -public: - typedef typename S::ObjectType &(L::*FuncType)(A0); + /** Loads statemsnts from a parser, feeding them directly to actions. */ + void load_direct(Parser &, unsigned); - SubLoader1(FuncType f): func(f) { } - void execute(L &l, const Statement &st) const - { - if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); - typename S::ObjectType &obj=(l.*func)(st.args[0].get()); - S sl(obj); - sl.load(st); - } -private: - FuncType func; -}; + /** Processes a single statement */ + void load_statement(const Statement &st); -template -class Loader -{ -public: - typedef C ObjectType; - - C &get_object() { return obj; } - 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) +protected: + /** Loads a sub-object from the statement being processed. The Loader class + of the sub-object is automatically used. */ + template + void load_sub(S &s) { - while(p) - { - Statement st=p.parse(); - if(st.valid) - load_statement(st); - } + typename S::Loader ldr(s); + load_sub_with(ldr); } - virtual ~Loader() + + /** Loads a sub-object from the statement being processed with an extra + parameter for the Loader. The Loader class of the sub-object is + automatically used. */ + template + void load_sub(S &s, T &p) { - for(typename ActionMap::iterator i=actions.begin(); i!=actions.end(); ++i) - delete i->second; + typename S::Loader ldr(s, p); + load_sub_with(ldr); } -protected: - typedef std::map *> ActionMap; - C &obj; - - Loader(C &o): obj(o) { } - + /** Processes the current statement's substatements with another Loader. */ + void load_sub_with(Loader &); + + /** Adds a keyword that is loaded by calling a function. */ + template void add(const std::string &k, void (L::*func)()) - { actions.insert(typename ActionMap::value_type(k, new LoaderFunc0(func))); } - - template + { add(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 + { add(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 + { add(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 + { add(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))); } + { add(k, new LoaderFunc4(func)); } - template - void add(const std::string &k, typename S::ObjectType &(L::*func)()) - { actions.insert(typename ActionMap::value_type(k, new SubLoader0(func))); } + template + void add(const std::string &k, void (L::*func)(A0, A1, A2, A3, A4)) + { add(k, new LoaderFunc5(func)); } + + /** Adds a keyword that is loaded into a member of the loaded object. */ + template + void add(const std::string &k, T0 L::*p0) + { add(k, new LoadValue1(p0)); } + + template + void add(const std::string &k, T0 L::*p0, T1 L::*p1) + { add(k, new LoadValue2(p0, p1)); } - template - void add(const std::string &k, typename S::ObjectType &(L::*func)(A0)) - { actions.insert(typename ActionMap::value_type(k, new SubLoader1(func))); } + /** Adds a keyword that is recognized but ignored. */ + void add(const std::string &k) + { add(k, 0); } - template - void add(const std::string &k, T C::*p) - { actions.insert(typename ActionMap::value_type(k, new LoadValue(p))); } private: - ActionMap actions; + void add(const std::string &, LoaderAction *); - void load_statement(const Statement &st) - { - typename ActionMap::iterator j=actions.find(st.keyword); - if(j==actions.end()) - throw Exception(st.get_location()+": Unknown keyword '"+st.keyword+"'"); - j->second->execute(dynamic_cast(*this), st); - } +protected: + void add_auxiliary_loader(Loader &); + +private: + bool has_action(const StatementKey &) const; + LoaderAction *find_action(const StatementKey &) const; + +protected: + /** Returns the source of the statement being processed. This can be used + to implement relative paths in include-like statements. Note that the + source may not necessarily be a file. */ + const std::string &get_source() const; + + /** Returns the keyword of the statement being processed. Can be used to + implement dynamic keywords. */ + const std::string &get_keyword() const; + + virtual void finish() { } }; -} // namespace Parser + +/** +Loads an object from a file. The object must have a public Loader class. +*/ +template +void load(T &obj, const std::string &fn) +{ + IO::BufferedFile in(fn); + + Parser parser(in, fn); + typename T::Loader loader(obj); + loader.load(parser); +} + +template +void load(T &obj, const std::string &fn, U &arg) +{ + IO::BufferedFile in(fn); + + Parser parser(in, fn); + typename T::Loader loader(obj, arg); + loader.load(parser); +} + +} // namespace DataFile } // namespace Msp #endif