From 11ed2b907c9b031b57c3d4fc5491fdc3460303c9 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Thu, 11 Sep 2008 19:04:35 +0000 Subject: [PATCH] Move LoaderActions to loaderaction.h Add basic loader classes to derive from Update Loader documentation --- source/loader.h | 263 +++++++++--------------------------------- source/loaderaction.h | 223 +++++++++++++++++++++++++++++++++++ 2 files changed, 278 insertions(+), 208 deletions(-) create mode 100644 source/loaderaction.h diff --git a/source/loader.h b/source/loader.h index 2a2d141..9314ab3 100644 --- a/source/loader.h +++ b/source/loader.h @@ -12,226 +12,34 @@ Distributed under the LGPL #include #include #include "except.h" +#include "loaderaction.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)(); - - LoaderFunc0(FuncType f): func(f) { } - void execute(Loader &l, const Statement &st) const - { - if(st.args.size()!=0) throw TypeError("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"); - (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"); - (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"); - (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); +Base class for data loaders. This class only provides core functionality. +You'll almost certainly want to use one of the BasicLoader classes instead. - LoaderFunc4(FuncType f): func(f) { } - void execute(Loader &l, const Statement &st) const - { - if(st.args.size()!=4) throw TypeError("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 LoaderFunc5: public LoaderAction -{ -public: - 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()!=5) throw TypeError("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: - FuncType func; -}; - - -template -class LoadValue1: public LoaderAction -{ -public: - typedef T0 L::*Pointer0Type; - - LoadValue1(Pointer0Type p0): ptr0(p0) { } - void execute(Loader &l, const Statement &st) const - { - if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); - dynamic_cast(l).get_object().*ptr0=st.args[0].get(); - } -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 - { - if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); - typename L::Loader &ldr=dynamic_cast(l); - ldr.get_object().*ptr0=ldr.get_collection().template get(st.args[0].get()); - } -private: - Pointer0Type ptr0; -}; +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. -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 - { - if(st.args.size()!=2) throw TypeError("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; -}; +A sub-object can be loaded with one of the load_sub functions. +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. -/** -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. +See also classes BasicLoader and BasicLoader2. */ class Loader { @@ -346,6 +154,45 @@ private: 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; } +}; + + +/** +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; + +protected: + C &coll; + +public: + BasicLoader2(O &o, C &c): BasicLoader(o), coll(c) { } + C &get_collection() const { return coll; } +}; + + /** Loads an object from a file. The object must have a public Loader class. */ diff --git a/source/loaderaction.h b/source/loaderaction.h new file mode 100644 index 0000000..2a2a8fc --- /dev/null +++ b/source/loaderaction.h @@ -0,0 +1,223 @@ +/* $Id$ + +This file is part of libmspdatafile +Copyright © 2006-2008 Mikko Rasa, Mikkosoft Productions +Distributed under the LGPL +*/ + +#ifndef MSP_DATAFILE_LOADERACTION_H_ +#define MSP_DATAFILE_LOADERACTION_H_ + +#include "except.h" +#include "statement.h" + +namespace Msp { +namespace DataFile { + +class Loader; + +/** +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"); + (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"); + (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"); + (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"); + (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"); + (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 LoaderFunc5: public LoaderAction +{ +public: + 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()!=5) throw TypeError("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: + FuncType func; +}; + + +template +class LoadValue1: public LoaderAction +{ +public: + typedef T0 L::*Pointer0Type; + + LoadValue1(Pointer0Type p0): ptr0(p0) { } + void execute(Loader &l, const Statement &st) const + { + if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); + dynamic_cast(l).get_object().*ptr0=st.args[0].get(); + } +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 + { + if(st.args.size()!=1) throw TypeError("Wrong number of arguments"); + typename L::Loader &ldr=dynamic_cast(l); + ldr.get_object().*ptr0=ldr.get_collection().template get(st.args[0].get()); + } +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 + { + if(st.args.size()!=2) throw TypeError("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; +}; + +} // namespace DataFile +} // namespace Msp + +#endif -- 2.45.2