extreme refactoring

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

diff --git a/src/serializable.hh b/src/Moof/Serializable.hh
similarity index 50%
rename from src/serializable.hh
rename to src/Moof/Serializable.hh
index 967b2133376ffc2a43b20fe94ac5edc237114f34..458dbe8dcdf745f8d44ebc26ce498aaa179a137c 100644 (file)
--- a/src/serializable.hh
+++ b/src/Moof/Serializable.hh
@@ -26,29 +26,33 @@
 
 *******************************************************************************/
 
 
 *******************************************************************************/
 

-#ifndef _SERIALIZABLE_HH_
-#define _SERIALIZABLE_HH_
+#ifndef _MOOF_SERIALIZABLE_HH_
+#define _MOOF_SERIALIZABLE_HH_

 
 #include <iostream>
 
 #include <iostream>

-#include <string>

 #include <map>
 #include <map>

+#include <string>

 #include <vector>
 
 #include <vector>
 

-#include "stringtools.hh"
-#include "serializer.hh"
-#include "deserializer.hh"
+#include <Moof/Deserializer.hh>
+#include <Moof/Serializer.hh>
+#include <Moof/StringTools.hh>
+

 
 

+namespace Mf {

 
 

-namespace dc {

 
 

+/**
+ * Interface for a type which can be serialized and deserialized.
+ */

 
 

-class serializable
+class Serializable

 {
 public:
 {
 public:

-       virtual ~serializable();
+       virtual ~Serializable();

 
 

-       virtual void serialize(serializer& out) const = 0;
-       virtual void deserialize(deserializer& in) = 0;
+       virtual void serialize(Serializer& out) const = 0;
+       virtual void deserialize(Deserializer& in) = 0;

 
        virtual void print() const = 0;
 
 
        virtual void print() const = 0;
 


@@ -57,12 +61,12 @@ public:
        virtual bool get(bool& value);
        virtual bool get(std::string& value);
        virtual bool get(std::wstring& value);
        virtual bool get(bool& value);
        virtual bool get(std::string& value);
        virtual bool get(std::wstring& value);

-       virtual bool get(std::vector<serializable_ptr>& value);
-       virtual bool get(std::map<std::string,serializable_ptr>& value);
+       virtual bool get(std::vector<SerializablePtr>& value);
+       virtual bool get(std::map<std::string,SerializablePtr>& value);

 
        /*
         * To get a number value which may have been parsed as either an integer or
 
        /*
         * To get a number value which may have been parsed as either an integer or

-        * double, use these instead.
+        * double, use these getters instead.

         */
 
        bool getNumber(long&);
         */
 
        bool getNumber(long&);


@@ -73,58 +77,60 @@ public:
 
 
 template <class T>
 
 
 template <class T>

-class wrapper : public serializable
+class SerializableBase : public Serializable

 {
 public:
 {
 public:

-       wrapper() {}
-       wrapper(const T& var) : variable(var) {}
+       SerializableBase() {}
+       SerializableBase(const T& value) :
+               value_(value) {}

 
 

-       void serialize(serializer& out) const;
-       void deserialize(deserializer& in);
+       void serialize(Serializer& out) const;
+       void deserialize(Deserializer& in);

 
        void print() const;
        bool get(T& value);
 public:
 
        void print() const;
        bool get(T& value);
 public:

-       T variable;
+       T value_;

 };
 
 
 };
 
 

-class null : public serializable
+class SerializableNull : public Serializable

 {
 public:
 {
 public:

-       null() {}
-       void serialize(serializer& out) const;
-       void deserialize(deserializer& in);
+       SerializableNull() {}
+       void serialize(Serializer& out) const;
+       void deserialize(Deserializer& in);

        
        void print() const;
        bool isNull();
 };
 
 
        
        void print() const;
        bool isNull();
 };
 
 

-typedef wrapper<long>                                                                          wrapped_integer;
-typedef wrapper<double>                                                                                wrapped_real;
-typedef wrapper<bool>                                                                          wrapped_boolean;
-typedef wrapper<std::string>                                                           wrapped_string;
-typedef wrapper<std::wstring>                                                          wrapped_wstring;
-typedef wrapper<std::vector<serializable_ptr> >                                wrapped_array;
-typedef wrapper<std::map<std::string,serializable_ptr> >       wrapped_dictionary;
+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>
 
 
 
 template <class T>

-inline void wrapper<T>::serialize(serializer& out) const
+inline void SerializableBase<T>::serialize(Serializer& out) const

 {
 {

-       out.push(variable);
+       out.push(value_);

 }
 
 template <>
 inline void
 }
 
 template <>
 inline void

-wrapper<std::vector<serializable_ptr> >::serialize(serializer& out) const
+SerializableBase<std::vector<SerializablePtr> >::serialize(Serializer& out) const

 {
        out.pushArrayHead();
 
 {
        out.pushArrayHead();
 

-       std::vector<serializable_ptr>::const_iterator i;
-       for (i = variable.begin(); i < variable.end(); i++)
+       std::vector<SerializablePtr>::const_iterator i;
+       for (i = value_.begin(); i < value_.end(); i++)

        {
                (*i)->serialize(out);
        }
        {
                (*i)->serialize(out);
        }


@@ -134,12 +140,12 @@ wrapper<std::vector<serializable_ptr> >::serialize(serializer& out) const
 
 template <>
 inline void
 
 template <>
 inline void

-wrapper<std::map<std::string,serializable_ptr> >::serialize(serializer& out) const
+SerializableBase<std::map<std::string,SerializablePtr> >::serialize(Serializer& out) const

 {
        out.pushMapHead();
 
 {
        out.pushMapHead();
 

-       std::map<std::string,serializable_ptr>::const_iterator i;
-       for (i = variable.begin(); i != variable.end(); i++)
+       std::map<std::string,SerializablePtr>::const_iterator i;
+       for (i = value_.begin(); i != value_.end(); i++)

        {
                out.push((*i).first);
                (*i).second->serialize(out);
        {
                out.push((*i).first);
                (*i).second->serialize(out);


@@ -148,28 +154,28 @@ wrapper<std::map<std::string,serializable_ptr> >::serialize(serializer& out) con
        out.pushMapTail();
 }
 
        out.pushMapTail();
 }
 

-inline void null::serialize(serializer& out) const
+inline void SerializableNull::serialize(Serializer& out) const

 {
        out.pushNull();
 }
 
 
 template <class T>
 {
        out.pushNull();
 }
 
 
 template <class T>

-inline void wrapper<T>::deserialize(deserializer& in)
+inline void SerializableBase<T>::deserialize(Deserializer& in)

 {
        in.pop();
 }
 
 template <>
 {
        in.pop();
 }
 
 template <>

-inline void wrapper<std::vector<serializable_ptr> >::deserialize(deserializer& in)
+inline void SerializableBase<std::vector<SerializablePtr> >::deserialize(Deserializer& in)

 {
 {

-       serializable_ptr obj;
+       SerializablePtr obj;

 
        in.pop();
 
        while (obj = in.deserialize())
        {
 
        in.pop();
 
        while (obj = in.deserialize())
        {

-               variable.push_back(serializable_ptr(obj));
+               value_.push_back(SerializablePtr(obj));

        }
 
        in.pop();
        }
 
        in.pop();


@@ -177,9 +183,9 @@ inline void wrapper<std::vector<serializable_ptr> >::deserialize(deserializer& i
 
 template <>
 inline void
 
 template <>
 inline void

-wrapper<std::map<std::string,serializable_ptr> >::deserialize(deserializer& in)
+SerializableBase<std::map<std::string,SerializablePtr> >::deserialize(Deserializer& in)

 {
 {

-       serializable_ptr obj;
+       SerializablePtr obj;

 
        in.pop();
 
 
        in.pop();
 


@@ -188,65 +194,65 @@ wrapper<std::map<std::string,serializable_ptr> >::deserialize(deserializer& in)
                std::string key;
                if (obj->get(key))
                {
                std::string key;
                if (obj->get(key))
                {

-                       variable[key] = in.deserialize();
+                       value_[key] = in.deserialize();

                }
        }
 
        in.pop();
 }
 
                }
        }
 
        in.pop();
 }
 

-inline void null::deserialize(deserializer& in)
+inline void SerializableNull::deserialize(Deserializer& in)

 {
        in.pop();
 }
 
 
 template <class T>
 {
        in.pop();
 }
 
 
 template <class T>

-inline void wrapper<T>::print() const
+inline void SerializableBase<T>::print() const

 {
 {

-       std::cout << std::boolalpha << typeid(T).name() << "(" << variable << ")";
+       std::cout << std::boolalpha << typeid(T).name() << "(" << value_ << ")";

 }
 
 template <>
 }
 
 template <>

-inline void wrapper<std::wstring>::print() const
+inline void SerializableBase<std::wstring>::print() const

 {
 {

-       std::wcout << variable;
+       std::wcout << value_;

 }
 
 template <>
 }
 
 template <>

-inline void wrapper<std::vector<serializable_ptr> >::print() const
+inline void SerializableBase<std::vector<SerializablePtr> >::print() const

 {
        std::cout << "array";
 }
 
 template <>
 {
        std::cout << "array";
 }
 
 template <>

-inline void wrapper<std::map<std::string,serializable_ptr> >::print() const
+inline void SerializableBase<std::map<std::string,SerializablePtr> >::print() const

 {
 {

-       std::cout << "dictionary";
+       std::cout << "map";

 }
 
 }
 

-inline void null::print() const
+inline void SerializableNull::print() const

 {
        std::cout << "null";
 }
 
 
 template <class T>
 {
        std::cout << "null";
 }
 
 
 template <class T>

-inline bool wrapper<T>::get(T& value)
+inline bool SerializableBase<T>::get(T& value)

 {
 {

-       value = variable;
+       value = value_;

        return true;
 }
 
        return true;
 }
 

-inline bool null::isNull()
+inline bool SerializableNull::isNull()

 {
        return true;
 }
 
 
 {
        return true;
 }
 
 

-} // namespace dc
+} // namespace Mf

 
 

-#endif // _SERIALIZABLE_HH_
+#endif // _MOOF_SERIALIZABLE_HH_

 
 /** vim: set ts=4 sw=4 tw=80: *************************************************/
 
 
 /** vim: set ts=4 sw=4 tw=80: *************************************************/