Add a C++ client for presents.

It provides code generators for streamables, services and receivers, but not DObject.  It uses
Apple's CFNetwork for its sockets and builds with XCode, so it's limited to OS X and iOS. It should
be straightforward to replace both to make it cross-platform.



git-svn-id: svn+ssh://src.earth.threerings.net/narya/trunk@6264 542714f4-19e9-0310-aa3c-eee0fc999fb1

src/cpp/presents/streamers/StreamableStreamer.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "presents/Streamer.h"
+#include "presents/Streamable.h"
+
+template <typename T>
+class StreamableStreamer : public Streamer
+{
+public:
+    Shared<void> createObject (ObjectInputStream& in)
+    {
+        Shared<Streamable> streamable(new T());
+        streamable->readObject(in);
+        return streamable;
+    }
+
+    void writeObject (const Shared<void>& object, ObjectOutputStream& out)
+    {
+        ((Shared<T>&)object)->writeObject(out);
+    }
+};
+
+#define DECLARE_STREAMABLE() \
+    static const utf8& javaName (); \
+    static void registerWithPresents () { javaName(); } \
+    virtual const utf8& getJavaClassName () const { return javaName(); }
+
+#define DEFINE_STREAMABLE(nameString, StreamableClass) \
+    static const utf8& gStreamableClassRegistration = StreamableClass::javaName(); \
+    const utf8& StreamableClass::javaName () {\
+    static const utf8 JAVA_NAME = nameString; \
+    static bool gRegistered = false; \
+    if (!gRegistered) { registerStreamer(JAVA_NAME, new StreamableStreamer<StreamableClass>()); gRegistered = true; } \
+    return JAVA_NAME; }

src/cpp/presents/streamers/StringStreamer.cpp

@@ -0,0 +1,17 @@
+#include "presents/stable.h"
+#include "StringStreamer.h"
+
+#include <string>
+
+#include "../ObjectInputStream.h"
+#include "../ObjectOutputStream.h"
+
+Shared<void> StringStreamer::createObject (ObjectInputStream& in)
+{
+    return Shared<void>(new utf8(in.readUTF()));
+}
+
+void StringStreamer::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    out.writeUTF(*(boost::static_pointer_cast<utf8>(object)));
+}

src/cpp/presents/streamers/StringStreamer.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "../Streamer.h"
+
+class StringStreamer : public Streamer
+{
+public:
+    Shared<void> createObject (ObjectInputStream& in);
+    void writeObject (const Shared<void>& object, ObjectOutputStream& out);
+};

src/cpp/presents/streamers/VectorStreamer.h

@@ -0,0 +1,223 @@
+#pragma once
+
+#include "../Streamer.h"
+#include "presents/ArrayMask.h"
+
+template <typename T>
+class VectorStreamer : public Streamer
+{
+public:
+    Shared<void> createObject (ObjectInputStream& in);
+    void writeObject (const Shared<void>& object, ObjectOutputStream& out);
+};
+
+template <typename T>
+Shared<void> VectorStreamer<T>::createObject (ObjectInputStream& in)
+{
+    int length = in.readInt();
+    Shared< std::vector< Shared<T> > > v(new std::vector< Shared<T> >(length));
+    for (int ii = 0; ii < length; ++ii) {
+        Shared<void> read = in.readObject();
+        (*v)[ii] = boost::static_pointer_cast<T>(read);
+    }
+    return v;
+}
+
+template <typename T>
+void VectorStreamer<T>::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    Shared< std::vector< Shared<T> > >& v = (Shared< std::vector< Shared<T> > >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeObject((*v)[ii]);
+    }
+}
+
+template <>
+Shared<void> VectorStreamer<int8>::createObject (ObjectInputStream& in)
+{
+    int32 length = in.readInt();
+    Shared< std::vector<int8> > v(new std::vector<int8>(length));
+    for (int ii = 0; ii < length; ++ii) {
+        (*v)[ii] = in.readByte();
+    }
+    return v;
+}
+
+template <>
+void VectorStreamer<int8>::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    const Shared< std::vector<int8> >& v = (Shared< std::vector<int8> >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeByte((*v)[ii]);
+    }
+}
+
+template <>
+Shared<void> VectorStreamer<int16>::createObject (ObjectInputStream& in)
+{
+    int32 length = in.readInt();
+    Shared< std::vector<int16> > v(new std::vector<int16>(length));
+    for (int ii = 0; ii < length; ++ii) {
+        (*v)[ii] = in.readShort();
+    }
+    return v;
+}
+
+template <>
+void VectorStreamer<int16>::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    const Shared< std::vector<int16> >& v = (Shared< std::vector<int16> >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeShort((*v)[ii]);
+    }
+}
+
+template <>
+Shared<void> VectorStreamer<int32>::createObject (ObjectInputStream& in)
+{
+    int32 length = in.readInt();
+    Shared< std::vector<int32> > v(new std::vector<int32>(length));
+    for (int ii = 0; ii < length; ++ii) {
+        (*v)[ii] = in.readInt();
+    }
+    return v;
+}
+
+template <>
+void VectorStreamer<int32>::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    const Shared< std::vector<int32> >& v = (Shared< std::vector<int32> >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeInt((*v)[ii]);
+    }
+}
+
+template <>
+Shared<void> VectorStreamer<int64>::createObject (ObjectInputStream& in)
+{
+    int32 length = in.readInt();
+    Shared< std::vector<int64> > v(new std::vector<int64>(length));
+    for (int ii = 0; ii < length; ++ii) {
+        (*v)[ii] = in.readLong();
+    }
+    return v;
+}
+
+template <>
+void VectorStreamer<int64>::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    const Shared< std::vector<int64> >& v = (Shared< std::vector<int64> >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeLong((*v)[ii]);
+    }
+}
+
+template <>
+Shared<void> VectorStreamer<float>::createObject (ObjectInputStream& in)
+{
+    int32 length = in.readInt();
+    Shared< std::vector<float> > v(new std::vector<float>(length));
+    for (int ii = 0; ii < length; ++ii) {
+        (*v)[ii] = in.readFloat();
+    }
+    return v;
+}
+
+template <>
+void VectorStreamer<float>::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    const Shared< std::vector<float> >& v = (Shared< std::vector<float> >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeFloat((*v)[ii]);
+    }
+}
+
+template <>
+Shared<void> VectorStreamer<double>::createObject (ObjectInputStream& in)
+{
+    int32 length = in.readInt();
+    Shared< std::vector<double> > v(new std::vector<double>(length));
+    for (int ii = 0; ii < length; ++ii) {
+        (*v)[ii] = in.readDouble();
+    }
+    return v;
+}
+
+template <>
+void VectorStreamer<double>::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    const Shared< std::vector<double> >& v = (Shared< std::vector<double> >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeDouble((*v)[ii]);
+    }
+}
+
+template <>
+Shared<void> VectorStreamer<bool>::createObject (ObjectInputStream& in)
+{
+    int32 length = in.readInt();
+    Shared< std::vector<bool> > v(new std::vector<bool>(length));
+    for (int ii = 0; ii < length; ++ii) {
+        (*v)[ii] = in.readBoolean();
+    }
+    return v;
+}
+
+template <>
+void VectorStreamer<bool>::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    const Shared< std::vector<bool> >& v = (Shared< std::vector<bool> >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeBoolean((*v)[ii]);
+    }
+}
+
+template <>
+Shared<void> VectorStreamer< utf8 >::createObject (ObjectInputStream& in)
+{
+    int32 length = in.readInt();
+    Shared< std::vector< Shared<utf8> > > v(new std::vector< Shared<utf8> >(length));
+    ArrayMask mask(in);
+    for (int ii = 0; ii < length; ++ii) {
+        if (mask.isSet(ii)) {
+            (*v)[ii] = Shared<utf8>(new utf8(in.readUTF()));
+        } else {
+            (*v)[ii] = Shared<utf8>();
+        }
+    }
+    return v;
+}
+
+template <>
+void VectorStreamer< utf8 >::writeObject (const Shared<void>& object, ObjectOutputStream& out)
+{
+    const Shared< std::vector< Shared<utf8> > >& v = (Shared< std::vector< Shared<utf8> > >&)(object);
+    int length = v->size();
+    out.writeInt(length);
+    ArrayMask mask(length);
+    for (int ii = 0; ii < length; ++ii) {
+        if ((*v)[ii] != NULL) {
+            mask.set(ii);
+        }
+    }
+    mask.writeTo(out);
+    for (int ii = 0; ii < length; ++ii) {
+        out.writeUTF(*((*v)[ii]));
+    }
+}