X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FMoof%2FSerializable.hh;fp=src%2Fserializable.hh;h=458dbe8dcdf745f8d44ebc26ce498aaa179a137c;hp=967b2133376ffc2a43b20fe94ac5edc237114f34;hb=c2321281bf12a7efaedde930422c7ddbc92080d4;hpb=87bc17e55b0c1dc73ecc66df856d3f08fd7a7724

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 967b213..458dbe8 100644
--- 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 <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;
 
@@ -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(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&);
@@ -73,58 +77,60 @@ public:
 
 
 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);
 	}
@@ -134,12 +140,12 @@ wrapper<std::vector<serializable_ptr> >::serialize(serializer& out) const
 
 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);
@@ -148,28 +154,28 @@ wrapper<std::map<std::string,serializable_ptr> >::serialize(serializer& out) con
 	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();
@@ -177,9 +183,9 @@ inline void wrapper<std::vector<serializable_ptr> >::deserialize(deserializer& i
 
 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();
 
@@ -188,65 +194,65 @@ wrapper<std::map<std::string,serializable_ptr> >::deserialize(deserializer& in)
 		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: *************************************************/