X-Git-Url: http://git.tdb.fi/?p=libs%2Fdatafile.git;a=blobdiff_plain;f=source%2Floader.h;h=fe928048508d208aafe339def238a4cdc722dc2d;hp=0c1dda2cc776db8d293b8696ba6e0e4739aab016;hb=1a3b30ea35fbc19e56bbd35e4ee1811d8d5e02a4;hpb=db9c49893c2a9475cb5efa4a53bc481a5f66231f diff --git a/source/loader.h b/source/loader.h index 0c1dda2..fe92804 100644 --- a/source/loader.h +++ b/source/loader.h @@ -1,17 +1,8 @@ -/* $Id$ - -This file is part of libmspdatafile -Copyright © 2006-2008 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - #ifndef MSP_DATAFILE_LOADER_H_ #define MSP_DATAFILE_LOADER_H_ #include -#include #include -#include "except.h" #include "loaderaction.h" #include "parser.h" #include "statement.h" @@ -39,29 +30,64 @@ 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. -See also classes BasicLoader and BasicLoader2. +See also classes ObjectLoader and CollectionObjectLoader in objectloader.h. */ class Loader { private: - /** - Loads data from a statement. - */ - void load(const Statement &st); + typedef std::map ActionMap; + + 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; + Loader(); public: - /** - Loads statements from a parser. - */ + virtual ~Loader(); + + /** Loads statements from a parser. */ void load(Parser &p); - virtual ~Loader(); +private: + /** 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); + + /** Processes a single statement */ + void load_statement(const Statement &st); + protected: - Loader(): cur_st(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) + { + typename S::Loader ldr(s); + load_sub_with(ldr); + } + + /** 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 &); - /** - Adds a keyword that is loaded with a zero-argument function. - */ + /** Adds a keyword that is loaded by calling a function. */ template void add(const std::string &k, void (L::*func)()) { add(k, new LoaderFunc0(func)); } @@ -86,9 +112,7 @@ protected: 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. - */ + /** 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)); } @@ -97,98 +121,31 @@ protected: 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. - */ + /** Adds a keyword that is recognized but ignored. */ void add(const std::string &k) { 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) - { - typename S::Loader ldr(s); - load_sub_with(ldr); - } - - /** - 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 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 add(const std::string &, LoaderAction *); - void load_statement(const Statement &st); -}; - - -/** -Provides the basic functionality of an object loader. Deriving from this -allows loading values directly into member variables of the objects. -*/ -template -class BasicLoader: public Loader -{ -public: - typedef O Object; protected: - O &obj; - -public: - BasicLoader(O &o): obj(o) { } - O &get_object() const { return obj; } -}; + void add_auxiliary_loader(Loader &); - -/** -Provides functionality for loading objects with a Collection. Deriving from -this allows loading pointers to objects in the collection automatically. -*/ -template -class BasicLoader2: public BasicLoader -{ -public: - typedef C Collection; +private: + bool has_action(const StatementKey &) const; + LoaderAction *find_action(const StatementKey &) const; protected: - C &coll; + /** 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; -public: - BasicLoader2(O &o, C &c): BasicLoader(o), coll(c) { } - C &get_collection() const { return coll; } + /** Returns the keyword of the statement being processed. Can be used to + implement dynamic keywords. */ + const std::string &get_keyword() const; + + virtual void finish() { } }; @@ -198,10 +155,9 @@ Loads an object from a file. The object must have a public Loader class. template void load(T &obj, const std::string &fn) { - IO::File in(fn); - IO::Buffered buf(in); + IO::BufferedFile in(fn); - Parser parser(buf, fn); + Parser parser(in, fn); typename T::Loader loader(obj); loader.load(parser); } @@ -209,10 +165,9 @@ void load(T &obj, const std::string &fn) template void load(T &obj, const std::string &fn, U &arg) { - IO::File in(fn); - IO::Buffered buf(in); + IO::BufferedFile in(fn); - Parser parser(buf, fn); + Parser parser(in, fn); typename T::Loader loader(obj, arg); loader.load(parser); }