X-Git-Url: http://git.tdb.fi/?p=libs%2Fdatafile.git;a=blobdiff_plain;f=source%2Floader.h;h=574ecce0c11b5bac9af56d82b6a0782a5288d8b6;hp=70fb7c2ba762fa2b2a4677c53363ffe7426d3009;hb=9c95942d24a92abea14bb9e11d33daae2d017321;hpb=de02b5618273df1b94085934f699371b4be31783 diff --git a/source/loader.h b/source/loader.h index 70fb7c2..574ecce 100644 --- a/source/loader.h +++ b/source/loader.h @@ -1,303 +1,204 @@ -/* $Id$ - -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_ -#include #include -#include "error.h" +#include +#include "loaderaction.h" +#include "meta.h" #include "parser.h" #include "statement.h" -#include "value.h" namespace Msp { 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)(); +Base class for data loaders. This class only provides core functionality. +You'll almost certainly want to use one of the BasicLoader classes instead. - LoaderFunc0(FuncType f): func(f) { } - void execute(Loader &l, const Statement &st) const - { - if(st.args.size()!=0) throw TypeError(st.get_location()+": Wrong number of arguments"); - (dynamic_cast(l).*func)(); - }; -private: - FuncType func; -}; +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. +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. -/** -Loads a statement by calling a function that takes one argument. -*/ -template -class LoaderFunc1: public LoaderAction -{ -public: - typedef void (L::*FuncType)(A0); +A sub-object can be loaded with one of the load_sub functions. - LoaderFunc1(FuncType f): func(f) { } - 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).*func)(st.args[0].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. - -/** -Loads a statement by calling a function that takes an array of values. +See also classes ObjectLoader and CollectionObjectLoader in objectloader.h. */ -template -class LoaderFunc1 &>: public LoaderAction +class Loader: private NonCopyable { -public: - typedef void (L::*FuncType)(const std::list &); - - LoaderFunc1(FuncType f): func(f) { } - void execute(Loader &l, const Statement &st) const +protected: + class ActionMap: public std::map, private NonCopyable { - 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); + public: + ~ActionMap(); + }; - LoaderFunc2(FuncType f): func(f) { } - void execute(Loader &l, const Statement &st) const - { - if(st.args.size()!=2) throw TypeError(st.get_location()+": Wrong number of arguments"); - (dynamic_cast(l).*func)(st.args[0].get(), st.args[1].get()); - } private: - FuncType func; -}; - + ActionMap local_actions; + ActionMap *actions; + Parser *cur_parser; + unsigned cur_level; + const Statement *cur_st; + bool sub_loaded; + bool direct; + std::vector aux_loaders; +protected: + bool check_sub_loads; -template -class LoaderFunc3: public LoaderAction -{ + Loader(); public: - typedef void (L::*FuncType)(A0, A1, A2); - - LoaderFunc3(FuncType f): func(f) { } - void execute(Loader &l, const Statement &st) const - { - if(st.args.size()!=3) throw TypeError(st.get_location()+": Wrong number of arguments"); - (dynamic_cast(l).*func)(st.args[0].get(), st.args[1].get(), st.args[2].get()); - } -private: - FuncType func; -}; + virtual ~Loader() { } + /** Loads statements from a parser. */ + void load(Parser &p); -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 - { - if(st.args.size()!=4) throw TypeError(st.get_location()+": Wrong number of arguments"); - (dynamic_cast(l).*func)(st.args[0].get(), st.args[1].get(), st.args[2].get(), st.args[3].get()); - } private: - FuncType func; -}; + /** Loads data from a statement. */ + void load(const Statement &st); + /** Loads statemsnts from a parser, feeding them directly to actions. */ + void load_direct(Parser &, unsigned); -template -class LoadValue1: public LoaderAction -{ -public: - typedef T0 L::*Pointer0Type; + /** Processes a single statement */ + void load_statement(const Statement &st); - LoadValue1(Pointer0Type p0): ptr0(p0) { } - void execute(Loader &l, const Statement &st) const +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) { - if(st.args.size()!=1) throw TypeError(st.get_location()+": Wrong number of arguments"); - dynamic_cast(l).get_object().*ptr0=st.args[0].get(); + typename S::Loader ldr(s); + load_sub_with(ldr); } -private: - Pointer0Type ptr0; -}; - -template -class LoadValue2: public LoaderAction -{ -public: - 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 + /** 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) { - 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(); + typename S::Loader ldr(s, p); + load_sub_with(ldr); } -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); + /** Processes the current statement's substatements with another Loader. */ + void load_sub_with(Loader &); - virtual ~Loader(); -protected: - Loader(): cur_st(0) { } + /** Sets the actions to be used when loading. If the map is empty, + init_actions will be called. */ + void set_actions(ActionMap &); + virtual void init_actions() { } + /** 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))); } + { 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 - void add(const std::string &k, void (L::*func)(A0, A1)) - { actions.insert(typename ActionMap::value_type(k, new LoaderFunc2(func))); } + { add(k, new LoaderFunc1(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)(Args...)) + { add(k, new LoaderFuncN(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))); } + /** Adds a keyword that is loaded by calling a function with a bound + first argument. */ + template + void add(const std::string &k, void (L::*func)(B0, Args...), const typename RemoveReference::Type &b0) + { add(k, new LoaderFuncNBound1(func, b0)); } + /** Adds a keyword that is loaded into a member of the loaded object. */ template void add(const std::string &k, T0 L::*p0) - { actions.insert(typename ActionMap::value_type(k, new LoadValue1(p0))); } + { add(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))); } + { add(k, new LoadValue2(p0, p1)); } + /** Adds a keyword that is recognized but ignored. */ void add(const std::string &k) - { actions.insert(ActionMap::value_type(k, 0)); } + { add(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); } +private: + void add(const std::string &, LoaderAction *); - /** - Loads a sub-object with a custom Loader class. - */ - template - void load_sub(S &s) - { - if(!cur_st) - throw InvalidState("load_sub called without current statement"); - L loader(s); - loader.load(*cur_st); - } +protected: + void add_auxiliary_loader(Loader &); - /** - 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; + bool has_action(const StatementKey &) const; + LoaderAction *find_action(const StatementKey &) const; - ActionMap actions; - const Statement *cur_st; +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; - void load_statement(const Statement &st); + /** Returns the keyword of the statement being processed. Can be used to + implement dynamic keywords. */ + const std::string &get_keyword() const; + + virtual void finish() { } }; + /** -Loads an object from a file. The object must have a public Loader class. +Loads an object from a file. The object must have a public Loader class. Any +extra arguments are passed to the Loader constructor. */ -template -void load(T &obj, const std::string &fn) +template +void load(T &obj, const std::string &fn, Args &... args) { - std::ifstream in(fn.c_str()); - if(!in) - throw Exception("Couldn't open "+fn); + IO::BufferedFile in(fn); Parser parser(in, fn); - typename T::Loader loader(obj); + typename T::Loader loader(obj, args...); + loader.load(parser); +} + +/** +Loads an object from a file stored in a collection. The object must have a +public Loader class. The collection is passed to the Loader constructor, +followed by any extra arguments. +*/ +template +void load(T &obj, typename T::Loader::Collection &coll, const std::string &fn, Args &... args) +{ + RefPtr in = coll.open_raw(fn); + if(!in) + throw IO::file_not_found(fn); + + Parser parser(*in, fn); + typename T::Loader loader(obj, coll, args...); + loader.load(parser); +} + +/** +Loads an object from a file stored in a collection. The object must havea +public Loader class. Any extra arguments are passed to the Loader constructor. +*/ +template +typename EnableIf::value, void>::No load(T &obj, C &coll, const std::string &fn, Args &... args) +{ + RefPtr in = coll.open_raw(fn); + if(!in) + throw IO::file_not_found(fn); + + Parser parser(*in, fn); + typename T::Loader loader(obj, args...); loader.load(parser); }