dispatcher alias methods

[chaz/yoink] / src / Moof / Serializable.hh

diff --git a/src/Moof/Serializable.hh b/src/Moof/Serializable.hh
index 458dbe8dcdf745f8d44ebc26ce498aaa179a137c..e91660d53d3752937d7e2f342607acced3d57719 100644 (file)
--- a/src/Moof/Serializable.hh
+++ b/src/Moof/Serializable.hh
@@ -46,9 +46,18 @@ namespace Mf {
  * Interface for a type which can be serialized and deserialized.
  */
 
-class Serializable
+struct Serializable
 {
-public:
+       // basic types which are serializable
+       typedef long                                                            Integer;
+       typedef double                                                          Float;
+       typedef bool                                                            Boolean;
+       typedef std::string                                                     String;
+       typedef std::wstring                                            WideString;
+       typedef std::vector<SerializableP>                      Array;
+       typedef std::map<String,SerializableP>          Map;
+
+
        virtual ~Serializable();
 
        virtual void serialize(Serializer& out) const = 0;
@@ -56,32 +65,35 @@ public:
 
        virtual void print() const = 0;
 
-       virtual bool get(long& value);
-       virtual bool get(double& value);
-       virtual bool get(bool& value);
-       virtual bool get(std::string& value);
-       virtual bool get(std::wstring& value);
-       virtual bool get(std::vector<SerializablePtr>& value);
-       virtual bool get(std::map<std::string,SerializablePtr>& value);
+       virtual bool get(Integer& value);
+       virtual bool get(Float& value);
+       virtual bool get(Boolean& value);
+       virtual bool get(String& value);
+       virtual bool get(WideString& value);
+       virtual bool get(Array& value);
+       virtual bool get(Map& value);
 
        /*
         * To get a number value which may have been parsed as either an integer or
         * double, use these getters instead.
         */
 
-       bool getNumber(long&);
-       bool getNumber(double&);
+       bool getNumber(Integer& value);
+       bool getNumber(Float& value);
 
        virtual bool isNull();
 };
 
 
 template <class T>
-class SerializableBase : public Serializable
+class SerializableBasic : public Serializable
 {
+       T value_;
+
 public:
-       SerializableBase() {}
-       SerializableBase(const T& value) :
+
+       SerializableBasic() {}
+       SerializableBasic(const T& value) :
                value_(value) {}
 
        void serialize(Serializer& out) const;
@@ -89,15 +101,13 @@ public:
 
        void print() const;
        bool get(T& value);
-public:
-       T value_;
 };
 
 
-class SerializableNull : public Serializable
+struct SerializableNull : public Serializable
 {
-public:
        SerializableNull() {}
+
        void serialize(Serializer& out) const;
        void deserialize(Deserializer& in);
        
@@ -106,33 +116,22 @@ public:
 };
 
 
-typedef SerializableBase<long>                                                         SerializableInteger;
-typedef SerializableBase<double>                                                       SerializableReal;
-typedef SerializableBase<bool>                                                         SerializableBoolean;
-typedef SerializableBase<std::string>                                          SerializableString;
-typedef SerializableBase<std::wstring>                                         SerializableWideString;
-typedef SerializableBase<std::vector<SerializablePtr> >        SerializableArray;
-typedef SerializableBase<std::map<std::string,SerializablePtr> >
-                                                                                                                       SerializableMap;
-
-
-
 template <class T>
-inline void SerializableBase<T>::serialize(Serializer& out) const
+inline void SerializableBasic<T>::serialize(Serializer& out) const
 {
        out.push(value_);
 }
 
 template <>
 inline void
-SerializableBase<std::vector<SerializablePtr> >::serialize(Serializer& out) const
+SerializableBasic<Serializable::Array>::serialize(Serializer& out) const
 {
        out.pushArrayHead();
 
-       std::vector<SerializablePtr>::const_iterator i;
-       for (i = value_.begin(); i < value_.end(); i++)
+       std::vector<SerializableP>::const_iterator it;
+       for (it = value_.begin(); it < value_.end(); ++it)
        {
-               (*i)->serialize(out);
+               (*it)->serialize(out);
        }
 
        out.pushArrayTail();
@@ -140,15 +139,14 @@ SerializableBase<std::vector<SerializablePtr> >::serialize(Serializer& out) cons
 
 template <>
 inline void
-SerializableBase<std::map<std::string,SerializablePtr> >::serialize(Serializer& out) const
+SerializableBasic<Serializable::Map>::serialize(Serializer& out) const
 {
        out.pushMapHead();
 
-       std::map<std::string,SerializablePtr>::const_iterator i;
-       for (i = value_.begin(); i != value_.end(); i++)
+       for (Map::const_iterator it = value_.begin(); it != value_.end(); ++it)
        {
-               out.push((*i).first);
-               (*i).second->serialize(out);
+               out.push((*it).first);
+               (*it).second->serialize(out);
        }
 
        out.pushMapTail();
@@ -161,21 +159,22 @@ inline void SerializableNull::serialize(Serializer& out) const
 
 
 template <class T>
-inline void SerializableBase<T>::deserialize(Deserializer& in)
+inline void SerializableBasic<T>::deserialize(Deserializer& in)
 {
        in.pop();
 }
 
 template <>
-inline void SerializableBase<std::vector<SerializablePtr> >::deserialize(Deserializer& in)
+inline void
+SerializableBasic<Serializable::Array>::deserialize(Deserializer& in)
 {
-       SerializablePtr obj;
+       SerializableP obj;
 
        in.pop();
 
        while (obj = in.deserialize())
        {
-               value_.push_back(SerializablePtr(obj));
+               value_.push_back(obj);
        }
 
        in.pop();
@@ -183,9 +182,9 @@ inline void SerializableBase<std::vector<SerializablePtr> >::deserialize(Deseria
 
 template <>
 inline void
-SerializableBase<std::map<std::string,SerializablePtr> >::deserialize(Deserializer& in)
+SerializableBasic<Serializable::Map>::deserialize(Deserializer& in)
 {
-       SerializablePtr obj;
+       SerializableP obj;
 
        in.pop();
 
@@ -208,25 +207,25 @@ inline void SerializableNull::deserialize(Deserializer& in)
 
 
 template <class T>
-inline void SerializableBase<T>::print() const
+inline void SerializableBasic<T>::print() const
 {
        std::cout << std::boolalpha << typeid(T).name() << "(" << value_ << ")";
 }
 
 template <>
-inline void SerializableBase<std::wstring>::print() const
+inline void SerializableBasic<Serializable::WideString>::print() const
 {
        std::wcout << value_;
 }
 
 template <>
-inline void SerializableBase<std::vector<SerializablePtr> >::print() const
+inline void SerializableBasic<Serializable::Array>::print() const
 {
        std::cout << "array";
 }
 
 template <>
-inline void SerializableBase<std::map<std::string,SerializablePtr> >::print() const
+inline void SerializableBasic<Serializable::Map>::print() const
 {
        std::cout << "map";
 }
@@ -238,7 +237,7 @@ inline void SerializableNull::print() const
 
 
 template <class T>
-inline bool SerializableBase<T>::get(T& value)
+inline bool SerializableBasic<T>::get(T& value)
 {
        value = value_;
        return true;