2 files changed, 244 insertions, 24 deletions

diff --git a/src/FbTk/ResTraits.hh b/src/FbTk/ResTraits.hh
new file mode 100644
index 0000000..32be48d
--- /dev/null
+++ b/src/FbTk/ResTraits.hh
@@ -0,0 +1,208 @@
+// ResTraits.hh
+// Copyright (c) 2011 Pavel Labath (pavelo at centrum dot sk)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+#ifndef FBTK_RESTRAITS_HH
+#define FBTK_RESTRAITS_HH
+
+#include <stdexcept>
+#include <vector>
+
+#include "Luamm.hh"
+#include "StringUtil.hh"
+
+namespace FbTk {
+
+struct ConversionError: public std::runtime_error {
+    ConversionError(const std::string &msg) : std::runtime_error(msg) {}
+};
+
+/* Classes that "know" how to convert from string and lua representations
+ * into corresponding C++ types
+ */
+
+template<typename T>
+struct IntTraits {
+    typedef T Type;
+    static std::string toString(T x) { return StringUtil::number2String(x); }
+    static void toLua(T x, lua::state &l) { l.pushnumber(x); }
+
+    static T fromString(const std::string &x) {
+        T t;
+        if(StringUtil::extractNumber(x, t))
+            return t;
+        throw ConversionError("Cannot convert to integer from '" + x + "'");
+    }
+
+    static T fromLua(lua::state &l) {
+        lua::stack_sentry s(l, -1);
+
+        if(l.isnumber(-1))
+            return l.tonumber(-1);
+        else if(l.isstring(-1))
+            return fromString(l.tostring(-1));
+        throw ConversionError( std::string("Cannot convert to integer from lua type ")
+                                + l.type_name(l.type(-1)) );
+    }
+};
+
+struct StringTraits {
+    typedef std::string Type;
+    static std::string toString(const std::string &x) { return x; }
+    static void toLua(const std::string &x, lua::state &l) { l.pushstring(x); }
+    static std::string fromString(const std::string &x) { return x; }
+
+    static std::string fromLua(lua::state &l) {
+        lua::stack_sentry s(l, -1);
+
+        if(l.isstring(-1) || l.isnumber(-1))
+            return fromString(l.tostring(-1));
+        throw ConversionError( std::string("Cannot convert to string from lua type ")
+                                + l.type_name(l.type(-1)) );
+    }
+};
+
+struct BoolTraits {
+    typedef bool Type;
+    static std::string toString(bool x) { return x ? "true" : "false"; }
+    static void toLua(bool x, lua::state &l) { l.pushboolean(x); }
+    static bool fromString(const std::string &x) {
+        return strcasecmp(x.c_str(), "true") == 0;
+    }
+
+    static bool fromLua(lua::state &l) {
+        lua::stack_sentry s(l, -1);
+
+        if(l.isstring(-1))
+            return fromString(l.tostring(-1));
+        else if(l.isnumber(-1))
+            return l.tointeger(-1) != 0;
+        else
+            return l.toboolean(-1);
+    }
+};
+
+/**
+ * To use this class, one must first define a mapping between enum values and their names using
+ * the s_map array. A NULL value for name signals the end of the array. E.g.,
+ * 
+ * template<>
+ * EnumTraits<Foo>::Pair EnumTraits<Foo>::s_map[] = { {"Bar", Bar}, {"Baz", Baz} {NULL, Baz} };
+ */
+template<typename T>
+struct EnumTraits {
+    typedef T Type;
+    struct Pair {
+        const char *name;
+        T value;
+    };
+    static const Pair s_map[];
+
+    static std::string toString(T x) {
+        for(const Pair *p = s_map; p->name; ++p) {
+            if(p->value == x)
+                return p->name;
+        }
+        throw ConversionError("Unknown value for enum");
+    }
+
+    static void toLua(T x, lua::state &l) { l.pushstring(toString(x)); }
+
+    static T fromString(const std::string &x) {
+        for(const Pair *p = s_map; p->name; ++p) {
+            if(strcasecmp(p->name, x.c_str()) == 0)
+                return p->value;
+        }
+        throw ConversionError("Cannot convert to enum from '" + x + "'");
+    }
+
+    static T fromLua(lua::state &l) {
+        lua::stack_sentry s(l, -1);
+
+        if(l.isstring(-1) || l.isnumber(-1))
+            return fromString(l.tostring(-1));
+        throw ConversionError( std::string("Cannot convert to enum from lua type ")
+                                + l.type_name(l.type(-1)) );
+    }
+};
+
+template<typename Traits>
+struct VectorTraits {
+    typedef std::vector<typename Traits::Type> Type;
+    static std::string toString(const Type &x) {
+        std::string retval;
+        for(size_t i = 0; i < x.size(); ++i) {
+            retval.append(Traits::toString(x[i]));
+            retval.append(" ");
+        }
+
+        return retval;
+    }
+
+    static void toLua(const Type &x, lua::state &l) {
+        l.checkstack(2);
+        l.createtable(x.size());
+        lua::stack_sentry s(l);
+
+        for(size_t i = 0; i < x.size(); ++i) {
+            Traits::toLua(x[i], l);
+            l.rawseti(-2, i);
+        }
+    }
+
+    static Type fromString(const std::string &x) {
+        std::vector<std::string> val;
+        StringUtil::stringtok(val, x);
+        Type retval;
+
+        for(size_t i = 0; i < val.size(); i++) {
+            try {
+                retval.push_back(Traits::fromString(val[i]));
+            }
+            catch(std::runtime_error &) {
+            }
+        }
+
+        return retval;
+    }
+
+    static Type fromLua(lua::state &l) {
+        l.checkstack(1);
+        lua::stack_sentry s(l, -1);
+        Type retval;
+
+        if(l.type(-1) == lua::TTABLE) {
+            for(size_t i = 0; l.rawgeti(-1, i), !l.isnil(-1); ++i) {
+                try {
+                    retval.push_back(Traits::fromLua(l));
+                }
+                catch(std::runtime_error &) {
+                }
+            }
+            return retval;
+        }
+        throw ConversionError( std::string("Cannot convert to vector from lua type ")
+                                + l.type_name(l.type(-1)) );
+    }
+};
+
+} // end namespace FbTk
+
+#endif // FBTK_RESTRAITS_HH
diff --git a/src/FbTk/Resource.hh b/src/FbTk/Resource.hh
index 1c53bff..fb05426 100644
--- a/src/FbTk/Resource.hh
+++ b/src/FbTk/Resource.hh
@@ -31,12 +31,9 @@
 
 #include <exception>
 #include <typeinfo>
+#include "ResTraits.hh"
 #include "XrmDatabaseHelper.hh"
 
-namespace lua {
-    class state;
-}
-
 namespace FbTk {
 
 class ResourceException: public std::exception {
@@ -82,7 +79,7 @@ private:
     std::string m_altname; ///< alternative name
 };
 
-template <typename T>
+template <typename T, typename Traits>
 class Resource;
 
 class ResourceManager_base
@@ -119,8 +116,8 @@ public:
      * it will throw exception if it fails
      * @return reference to resource type
      */
-    template <typename ResourceType>
-    Resource<ResourceType> &getResource(const std::string &resource);
+    template <typename ResourceType, typename Traits>
+    Resource<ResourceType, Traits> &getResource(const std::string &resource);
 };
 
 class ResourceManager: public ResourceManager_base
@@ -189,15 +186,10 @@ private:
 
 /// Real resource class
 /**
- * usage: Resource<int> someresource(resourcemanager, 10, "someresourcename", "somealternativename");
- * and then implement setFromString and getString
- * example:
- * template <>
- * void Resource<int>::setFromString(const char *str) {
- *   *(*this) = atoi(str);
- * }
+ * usage: Resource<int, IntTraits<int> > someresource(resourcemanager, 10, "someresourcename", "somealternativename");
+ * If there is no traits class for your type, you have to implement one.
  */
-template <typename T>
+template <typename T, typename Traits>
 class Resource:public Resource_base, public Accessor<T> {
 public:
     typedef T Type;
@@ -211,14 +203,30 @@ public:
 
     void setDefaultValue() {  m_value = m_defaultval; }
     /// sets resource from string, specialized, must be implemented
-    void setFromString(const char *strval);
+    void setFromString(const char *strval) {
+        try {
+            m_value = Traits::fromString(strval);
+        }
+        catch(ConversionError &e) {
+            std::cerr << name() << ": " << e.what() << std::endl;
+            setDefaultValue();
+        }
+    }
     Accessor<T> &operator =(const T& newvalue) { m_value = newvalue; return *this;}
     /// specialized, must be implemented
     /// @return string value of resource
-    std::string getString() const;
+    std::string getString() const { return Traits::toString(m_value); }
 
-    virtual void setFromLua(lua::state &l);
-    virtual void pushToLua(lua::state &l) const;
+    virtual void setFromLua(lua::state &l) {
+        try {
+            m_value = Traits::fromLua(l);
+        }
+        catch(ConversionError &e) {
+            std::cerr << name() << ": " << e.what() << std::endl;
+            setDefaultValue();
+        }
+    }
+    virtual void pushToLua(lua::state &l) const { Traits::toLua(m_value, l); }
 
     operator T() const { return m_value; }
     T& get() { return m_value; }
@@ -232,17 +240,16 @@ private:
 };
 
 
-
-template <typename ResourceType>
-Resource<ResourceType> &ResourceManager_base::getResource(const std::string &resname) {
+template <typename ResourceType, typename Traits>
+Resource<ResourceType, Traits> &ResourceManager_base::getResource(const std::string &resname) {
     Resource_base *res = findResource(resname);
     if (res == 0) {
         throw ResourceException("Could not find resource \"" +
                                 resname + "\"");
     }
 
-    Resource<ResourceType> *res_type =
-        dynamic_cast<Resource<ResourceType> *>(res);
+    Resource<ResourceType, Traits> *res_type =
+        dynamic_cast<Resource<ResourceType, Traits> *>(res);
     if (res_type == 0) {
         throw ResourceException("Could not convert resource \"" +
                                 resname +
@@ -252,6 +259,11 @@ Resource<ResourceType> &ResourceManager_base::getResource(const std::string &res
     return *res_type;
 }
 
+typedef Resource<bool, BoolTraits> BoolResource;
+typedef Resource<int, IntTraits<int> > IntResource;
+typedef Resource<unsigned int, IntTraits<unsigned int> > UIntResource;
+typedef Resource<std::string, StringTraits> StringResource;
+
 } // end namespace FbTk
 
 #endif // FBTK_RESOURCE_HH