* 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;
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;
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);
};
-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 it;
+ std::vector<SerializableP>::const_iterator it;
for (it = value_.begin(); it < value_.end(); ++it)
{
(*it)->serialize(out);
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 it;
- for (it = value_.begin(); it != value_.end(); ++it)
+ for (Map::const_iterator it = value_.begin(); it != value_.end(); ++it)
{
out.push((*it).first);
(*it).second->serialize(out);
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();
template <>
inline void
-SerializableBase<std::map<std::string,SerializablePtr> >::deserialize(Deserializer& in)
+SerializableBasic<Serializable::Map>::deserialize(Deserializer& in)
{
- SerializablePtr obj;
+ SerializableP obj;
in.pop();
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";
}
template <class T>
-inline bool SerializableBase<T>::get(T& value)
+inline bool SerializableBasic<T>::get(T& value)
{
value = value_;
return true;