First integration of TypeStream into existing code. Testing as well

as class partitioning and encapsulation remains to be done.

diff --git a/src/CommonAPI/OutputStream.h b/src/CommonAPI/OutputStream.h
index c08a495..d3d62f0 100644 (file)
--- a/src/CommonAPI/OutputStream.h
+++ b/src/CommonAPI/OutputStream.h
@@ -238,21 +238,6 @@ template<typename _Type>
 struct TypeWriter: public VariantTypeWriter<_Type, std::is_base_of<CommonAPI::SerializableVariant, _Type>::value>{};
 
 
-struct TypeSearchVisitor {
-public:
-    TypeSearchVisitor(TypeOutputStream& typeStream): typeStream_(typeStream) {
-    }
-
-    template<typename _Type>
-    void operator()(const _Type& currentType) const {
-        TypeWriter<_Type>::writeType(typeStream_);
-    }
-
-private:
-    TypeOutputStream& typeStream_;
-};
-
-
 
 class OutputStream {
  public:
@@ -318,8 +303,6 @@ class OutputStream {
 
        virtual void beginWriteMap(size_t elementCount) = 0;
        virtual void endWriteMap() = 0;
-
-       virtual std::shared_ptr<TypeOutputStream> getNewTypeOutputStream() = 0;
 };
 
 
@@ -388,11 +371,6 @@ inline OutputStream& operator<<(OutputStream& outputStream, const SerializableSt
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const SerializableVariant& serializableVariant) {
-    std::shared_ptr<TypeOutputStream> typeOutStream = outputStream.getNewTypeOutputStream();
-
-//    CommonAPI::TypeSearchVisitor searchVisitor(typeStream_);
-//    CommonAPI::ApplyVoidVisitor<CommonAPI::TypeSearchVisitor, CommonAPI::Variant<uint32_t, double, TestStruct>, uint32_t, double, TestStruct>::visit(searchVisitor, myVariant);
-
     outputStream.beginWriteSerializableVariant(serializableVariant);
     serializableVariant.writeToOutputStream(outputStream);
     outputStream.endWriteSerializableVariant(serializableVariant);

diff --git a/src/CommonAPI/SerializableVariant.h b/src/CommonAPI/SerializableVariant.h
index 35a5d4f..c2c9629 100644 (file)
--- a/src/CommonAPI/SerializableVariant.h
+++ b/src/CommonAPI/SerializableVariant.h
@@ -22,6 +22,9 @@ class OutputStream;
 
 class TypeOutputStream;
 
+template<typename _Type>
+struct TypeWriter;
+
 class SerializableVariant {
 public:
     virtual ~SerializableVariant() {
@@ -31,6 +34,8 @@ public:
 
     virtual void readFromInputStream(InputStream& inputStream) = 0;
     virtual void writeToOutputStream(OutputStream& outputStream) const = 0;
+
+    virtual void writeToTypeOutputStream(TypeOutputStream& typeOutputStream) const = 0;
 };
 
 template<typename ... _Types>
@@ -54,6 +59,12 @@ struct ApplyVoidVisitor<Visitor, Variant> {
         //won't be called
         assert(false);
     }
+
+    static
+    void visit(Visitor&, const Variant&) {
+        //won't be called
+        assert(false);
+    }
 };
 
 template<class Visitor, class Variant, typename _Type, typename ... _Types>
@@ -70,6 +81,16 @@ struct ApplyVoidVisitor<Visitor, Variant, _Type, _Types...> {
             ApplyVoidVisitor<Visitor, Variant, _Types...>::visit(visitor, var);
         }
     }
+
+    static
+    void visit(Visitor& visitor, const Variant& var) {
+        if (var.getValueType() == index) {
+            bool b;
+            visitor(var.template get<_Type>(b));
+        } else {
+            ApplyVoidVisitor<Visitor, Variant, _Types...>::visit(visitor, var);
+        }
+    }
 };
 
 template<class Visitor, class Variant, typename ... _Types>
@@ -118,6 +139,20 @@ private:
     typename std::aligned_storage<size>::type& storage_;
 };
 
+struct TypeWriteVisitor {
+public:
+    TypeWriteVisitor(TypeOutputStream& typeStream): typeStream_(typeStream) {
+    }
+
+    template<typename _Type>
+    void operator()(const _Type&) const {
+        TypeWriter<_Type>::writeType(typeStream_);
+    }
+
+private:
+    TypeOutputStream& typeStream_;
+};
+
 template<typename _U, typename ... _Types>
 struct TypeSelector;
 
@@ -272,8 +307,9 @@ public:
         //TODO
     }
 
-    static void writeToTypeOutputStream(TypeOutputStream& typeOutputStream) {
-        //TODO
+    virtual void writeToTypeOutputStream(TypeOutputStream& typeOutputStream) const {
+        TypeWriteVisitor visitor(typeOutputStream);
+        ApplyVoidVisitor<TypeWriteVisitor, Variant<_Types...>, _Types...>::visit(visitor, *this);
     }
 
     Variant& operator=(const Variant& rhs)