X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Floader.h;h=5b39212e53c32beceda2cc3227109dc9eb4c9b6c;hb=d84673be1c2fe8bd32ddaa7877529855cad6daa0;hp=c6936f96f6eef5869f62ffe3ed9307f34038dd2c;hpb=47597fd1b0b11c915466dd7f3f1281906442377c;p=libs%2Fdatafile.git diff --git a/source/loader.h b/source/loader.h index c6936f9..5b39212 100644 --- a/source/loader.h +++ b/source/loader.h @@ -1,224 +1,377 @@ -/* -This file is part of libmspparser +/* $Id$ + +This file is part of libmspdatafile Copyright © 2006 Mikko Rasa, Mikkosoft Productions Distributed under the LGPL */ -#ifndef MSP_PARSER_LOADER_H_ -#define MSP_PARSER_LOADER_H_ -#include +#ifndef MSP_DATAFILE_LOADER_H_ +#define MSP_DATAFILE_LOADER_H_ + #include -#include +#include +#include +#include "except.h" #include "parser.h" #include "statement.h" #include "value.h" namespace Msp { -namespace Parser { +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 { - if(st.args.size()!=0) throw TypeError("Wrong number of arguments"); + if(st.args.size()!=0) throw TypeError(st.get_location()+": Wrong number of arguments"); (dynamic_cast(l).*func)(); }; 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 { - if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); + 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; }; + +/** +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::vector &); + + LoaderFunc1(FuncType f): func(f) { } + void execute(Loader &l, const Statement &st) const + { + std::vector values; + values.reserve(st.args.size()); + for(ValueArray::const_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 { - if(st.args.size()!=2) throw TypeError("Wrong number of arguments"); + 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; }; + 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 { - if(st.args.size()!=3) throw TypeError("Wrong number of arguments"); + 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; }; + 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("Wrong number of arguments"); + 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; }; -template -class LoadValue: public LoaderAction + +template +class LoaderFunc5: public LoaderAction { public: - typedef T L::*PointerType; - - LoadValue(PointerType p): ptr(p) { } + typedef void (L::*FuncType)(A0, A1, A2, A3, A4); + + LoaderFunc5(FuncType f): func(f) { } void execute(Loader &l, const Statement &st) const { - if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); - dynamic_cast(l).get_object().*ptr=st.args[0].get(); + if(st.args.size()!=5) 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(), st.args[4].get()); } private: - PointerType ptr; + FuncType func; }; -class Loader + +template +class LoadValue1: public LoaderAction { public: - void load(const Statement &st) + typedef T0 L::*Pointer0Type; + + LoadValue1(Pointer0Type p0): ptr0(p0) { } + void execute(Loader &l, const Statement &st) const { - for(std::list::const_iterator i=st.sub.begin(); i!=st.sub.end(); ++i) - load_statement(*i); + if(st.args.size()!=1) throw TypeError(st.get_location()+": Wrong number of arguments"); + dynamic_cast(l).get_object().*ptr0=st.args[0].get(); } - void load(Parser &p) +private: + Pointer0Type ptr0; +}; + + +template +class LoadValue1: public LoaderAction +{ +public: + typedef T0 *L::*Pointer0Type; + + LoadValue1(Pointer0Type p0): ptr0(p0) { } + void execute(Loader &l, const Statement &st) const { - while(p) - { - Statement st=p.parse(); - if(st.valid) - load_statement(st); - } + if(st.args.size()!=1) throw TypeError(st.get_location()+": Wrong number of arguments"); + typename L::Loader &ldr=dynamic_cast(l); + ldr.get_object().*ptr0=ldr.get_collection().template get(st.args[0].get()); } - virtual ~Loader() +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 { - 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 give loading capabilities to a class, create a +public Loader class in it, derived from this class. Typically a loader object +contains a reference to the loaded object. To make use of loading directly +into data members, the Loader class must have a get_object() member function, +returning that reference. If direct loading of pointers is desired, the Loader +class must also have a get_collection() member function, returning a collection +to get pointers from. +*/ +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) { } - + + /** + Adds a keyword that is loaded with a zero-argument 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))); } - + { 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))); } - + { 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))); } - + { 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, void (L::*func)(A0, A1, A2, A3, A4)) + { add(k, new LoaderFunc5(func)); } + + /** + Adds a keyword that is loaded into a variable 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, T L::*p) - { actions.insert(typename ActionMap::value_type(k, new LoadValue(p))); } + template + void add(const std::string &k, T0 L::*p0, T1 L::*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 processed. The Loader class of + the sub-object is automatically used. + */ template void load_sub(S &s) - { load_sub(s); } + { + typename S::Loader ldr(s); + load_sub_with(ldr); + } - template - void load_sub(S &s) + /** + 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) + { + typename S::Loader ldr(s, p); + load_sub_with(ldr); + } + + /** + Processes the current statement's substatements with another Loader. + */ + void load_sub_with(Loader &); + + /** + 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 { if(!cur_st) - throw Exception("load_sub called without current statement"); - L loader(s); - loader.load(*cur_st); + throw InvalidState("get_source called without current statement"); + return cur_st->source; } + + virtual void finish() { } 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 add(const std::string &, LoaderAction *); + 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) { - std::ifstream in(fn.c_str()); - if(!in) - throw Exception("Couldn't open "+fn); + IO::File in(fn); + IO::Buffered buf(in); - Parser parser(in, fn); + Parser parser(buf, fn); typename T::Loader loader(obj); loader.load(parser); } -} // namespace Parser +template +void load(T &obj, const std::string &fn, U &arg) +{ + IO::File in(fn); + IO::Buffered buf(in); + + Parser parser(in, fn); + typename T::Loader loader(obj, arg); + loader.load(parser); +} + +} // namespace DataFile } // namespace Msp #endif