Handle unknown types as enums

Move some functions into loader.cpp
Add a LoaderAction for an arbitary number of arguments of the same type
Add a LoaderAction to load two values directly into member variables
Add an overload of load_sub that takes an extra parameter for the loader

diff --git a/source/loader.cpp b/source/loader.cpp
new file mode 100644 (file)
index 0000000..cf1a5ac
--- /dev/null
+++ b/source/loader.cpp
@@ -0,0 +1,49 @@
+/* $Id$
+
+This file is part of libmspdatafile
+Copyright © 2006  Mikko Rasa, Mikkosoft Productions
+Distributed under the LGPL
+*/
+
+#include "loader.h"
+
+using namespace std;
+
+namespace Msp {
+namespace DataFile {
+
+void Loader::load(const Statement &st)
+{
+       for(list<Statement>::const_iterator i=st.sub.begin(); i!=st.sub.end(); ++i)
+               load_statement(*i);
+}
+
+void Loader::load(Parser &p)
+{
+       while(p)
+       {
+               Statement st=p.parse();
+               if(st.valid)
+                       load_statement(st);
+       }
+}
+
+Loader::~Loader()
+{
+       for(ActionMap::iterator i=actions.begin(); i!=actions.end(); ++i)
+               delete i->second;
+}
+
+void Loader::load_statement(const Statement &st)
+{
+       cur_st=&st;
+       ActionMap::iterator j=actions.find(st.keyword);
+       if(j==actions.end())
+               throw KeyError(st.get_location()+": Unknown keyword '"+st.keyword+"'");
+       if(j->second)
+               j->second->execute(*this, st);
+       cur_st=0;
+}
+
+} // namespace DataFile
+} // namespace Msp

diff --git a/source/loader.h b/source/loader.h
index 48d4f9b4757842a7fcdf983d12badb15895d7499..70fb7c2ba762fa2b2a4677c53363ffe7426d3009 100644 (file)
--- a/source/loader.h
+++ b/source/loader.h
@@ -4,6 +4,7 @@ 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_
 
@@ -20,21 +21,31 @@ 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<typename L>
 class LoaderFunc0: public LoaderAction
 {
 public:
        typedef void (L::*FuncType)();
-       
+
        LoaderFunc0(FuncType f): func(f) { }
        void execute(Loader &l, const Statement &st) const
        {
@@ -45,12 +56,16 @@ private:
        FuncType func;
 };
 
+
+/**
+Loads a statement by calling a function that takes one argument.
+*/
 template<typename L, typename A0>
 class LoaderFunc1: public LoaderAction
 {
 public:
        typedef void (L::*FuncType)(A0);
-       
+
        LoaderFunc1(FuncType f): func(f) { }
        void execute(Loader &l, const Statement &st) const
        {
@@ -61,12 +76,36 @@ private:
        FuncType func;
 };
 
+
+/**
+Loads a statement by calling a function that takes an array of values.
+*/
+template<typename L, typename A0>
+class LoaderFunc1<L, const std::list<A0> &>: public LoaderAction
+{
+public:
+       typedef void (L::*FuncType)(const std::list<A0> &);
+
+       LoaderFunc1(FuncType f): func(f) { }
+       void execute(Loader &l, const Statement &st) const
+       {
+               std::vector<A0> values;
+               values.reserve(st.args.size());
+               for(ValueArray::iterator i=st.args.begin(); i!=st.args.end(); ++i)
+                       values.push_back(i->get<A0>());
+               (dynamic_cast<L &>(l).*func)(values);
+       }
+private:
+       FuncType func;
+};
+
+
 template<typename L, typename A0, typename A1>
 class LoaderFunc2: public LoaderAction
 {
 public:
        typedef void (L::*FuncType)(A0, A1);
-       
+
        LoaderFunc2(FuncType f): func(f) { }
        void execute(Loader &l, const Statement &st) const
        {
@@ -77,12 +116,13 @@ private:
        FuncType func;
 };
 
+
 template<typename L, typename A0, typename A1, typename A2>
 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
        {
@@ -93,12 +133,13 @@ private:
        FuncType func;
 };
 
+
 template<typename L, typename A0, typename A1, typename A2, typename A3>
 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
        {
@@ -109,104 +150,145 @@ private:
        FuncType func;
 };
 
-template<typename L, typename T>
-class LoadValue: public LoaderAction
+
+template<typename L, typename T0>
+class LoadValue1: public LoaderAction
 {
 public:
-       typedef T L::*PointerType;
-       
-       LoadValue(PointerType p): ptr(p) { }
+       typedef T0 L::*Pointer0Type;
+
+       LoadValue1(Pointer0Type p0): ptr0(p0) { }
        void execute(Loader &l, const Statement &st) const
        {
                if(st.args.size()!=1) throw TypeError(st.get_location()+": Wrong number of arguments");
-               dynamic_cast<typename L::Loader &>(l).get_object().*ptr=st.args[0].get<T>();
+               dynamic_cast<typename L::Loader &>(l).get_object().*ptr0=st.args[0].get<T0>();
        }
 private:
-       PointerType ptr;
+       Pointer0Type ptr0;
 };
 
-class Loader
+
+template<typename L, typename T0, typename T1>
+class LoadValue2: public LoaderAction
 {
 public:
-       void load(const Statement &st)
-       {
-               for(std::list<Statement>::const_iterator i=st.sub.begin(); i!=st.sub.end(); ++i)
-                       load_statement(*i);
-       }
-       void load(Parser &p)
-       {
-               while(p)
-               {
-                       Statement st=p.parse();
-                       if(st.valid)
-                               load_statement(st);
-               }
-       }
-       virtual ~Loader()
+       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<typename L::Loader &>(l).get_object().*ptr0=st.args[0].get<T0>();
+               dynamic_cast<typename L::Loader &>(l).get_object().*ptr1=st.args[1].get<T1>();
        }
+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);
+
+       virtual ~Loader();
 protected:
        Loader(): cur_st(0) { }
-       
+
        template<typename L>
        void add(const std::string &k, void (L::*func)())
        { actions.insert(typename ActionMap::value_type(k, new LoaderFunc0<L>(func))); }
-       
+
        template<typename L, typename A0>
        void add(const std::string &k, void (L::*func)(A0))
        { actions.insert(typename ActionMap::value_type(k, new LoaderFunc1<L, A0>(func))); }
-       
+
        template<typename L, typename A0, typename A1>
        void add(const std::string &k, void (L::*func)(A0, A1))
        { actions.insert(typename ActionMap::value_type(k, new LoaderFunc2<L, A0, A1>(func))); }
-       
+
        template<typename L, typename A0, typename A1, typename A2>
        void add(const std::string &k, void (L::*func)(A0, A1, A2))
        { actions.insert(typename ActionMap::value_type(k, new LoaderFunc3<L, A0, A1, A2>(func))); }
-       
+
        template<typename L, typename A0, typename A1, typename A2, typename A3>
        void add(const std::string &k, void (L::*func)(A0, A1, A2, A3))
        { actions.insert(typename ActionMap::value_type(k, new LoaderFunc4<L, A0, A1, A2, A3>(func))); }
 
-       template<typename L, typename T>
-       void add(const std::string &k, T L::*p)
-       { actions.insert(typename ActionMap::value_type(k, new LoadValue<L, T>(p))); }
+       template<typename L, typename T0>
+       void add(const std::string &k, T0 L::*p0)
+       { actions.insert(typename ActionMap::value_type(k, new LoadValue1<L, T0>(p0))); }
+
+       template<typename L, typename T0, typename T1>
+       void add(const std::string &k, T0 L::*p0, T1 L::*p1)
+       { actions.insert(typename ActionMap::value_type(k, new LoadValue2<L, T0, T1>(p0, p1))); }
 
        void add(const std::string &k)
        { actions.insert(ActionMap::value_type(k, 0)); }
 
+       /**
+       Loads a sub-object from the statement being currently processed.  The Loader
+       class of the sub-object is automatically used.
+       */
        template<typename S>
        void load_sub(S &s)
        { load_sub<S, typename S::Loader>(s); }
 
+       /**
+       Loads a sub-object with a custom Loader class.
+       */
        template<typename S, typename L>
        void load_sub(S &s)
        {
                if(!cur_st)
-                       throw Exception("load_sub called without current statement");
+                       throw InvalidState("load_sub called without current statement");
                L loader(s);
                loader.load(*cur_st);
        }
+
+       /**
+       Loads a sub-object with a custom Loader class that takes one argument in
+       addition to to object to be loaded.
+       */
+       template<typename S, typename L, typename T>
+       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<std::string, LoaderAction *> 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 load_statement(const Statement &st);
 };
 
+/**
+Loads an object from a file.  The object must have a public Loader class.
+*/
 template<typename T>
 void load(T &obj, const std::string &fn)
 {

diff --git a/source/value.h b/source/value.h
index 5ebbb5e1e52a101f475e7914089ed21b6febf051..f809c8fe4d3001cfba4660f45b9e9556a15d3ab8 100644 (file)
--- a/source/value.h
+++ b/source/value.h
@@ -36,7 +36,7 @@ private:
 };
 typedef std::vector<Value> ValueArray;
 
-template<typename T> struct TypeResolver { };
+template<typename T> struct TypeResolver { static const Value::Type type=Value::ENUM; };
 
 template<> struct TypeResolver<short>          { static const Value::Type type=Value::INTEGER; };
 template<> struct TypeResolver<unsigned short> { static const Value::Type type=Value::INTEGER; };