*******************************************************************************/
-#ifndef _SERIALIZABLE_HH_
-#define _SERIALIZABLE_HH_
+#ifndef _MOOF_SERIALIZABLE_HH_
+#define _MOOF_SERIALIZABLE_HH_
#include <iostream>
-#include <string>
#include <map>
+#include <string>
#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:
- 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 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
- * double, use these instead.
+ * double, use these getters instead.
*/
bool getNumber(long&);
template <class T>
-class wrapper : public serializable
+class SerializableBase : public Serializable
{
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:
- T variable;
+ T value_;
};
-class null : public serializable
+class SerializableNull : public Serializable
{
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();
};
-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>
-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
-wrapper<std::vector<serializable_ptr> >::serialize(serializer& out) const
+SerializableBase<std::vector<SerializablePtr> >::serialize(Serializer& out) const
{
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);
}
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();
- 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.pushMapTail();
}
-inline void null::serialize(serializer& out) const
+inline void SerializableNull::serialize(Serializer& out) const
{
out.pushNull();
}
template <class T>
-inline void wrapper<T>::deserialize(deserializer& in)
+inline void SerializableBase<T>::deserialize(Deserializer& in)
{
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())
{
- variable.push_back(serializable_ptr(obj));
+ value_.push_back(SerializablePtr(obj));
}
in.pop();
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();
std::string key;
if (obj->get(key))
{
- variable[key] = in.deserialize();
+ value_[key] = in.deserialize();
}
}
in.pop();
}
-inline void null::deserialize(deserializer& in)
+inline void SerializableNull::deserialize(Deserializer& in)
{
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 <>
-inline void wrapper<std::wstring>::print() const
+inline void SerializableBase<std::wstring>::print() const
{
- std::wcout << variable;
+ std::wcout << value_;
}
template <>
-inline void wrapper<std::vector<serializable_ptr> >::print() const
+inline void SerializableBase<std::vector<SerializablePtr> >::print() const
{
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>
-inline bool wrapper<T>::get(T& value)
+inline bool SerializableBase<T>::get(T& value)
{
- value = variable;
+ value = value_;
return true;
}
-inline bool null::isNull()
+inline bool SerializableNull::isNull()
{
return true;
}
-} // namespace dc
+} // namespace Mf
-#endif // _SERIALIZABLE_HH_
+#endif // _MOOF_SERIALIZABLE_HH_
/** vim: set ts=4 sw=4 tw=80: *************************************************/