Fixed (de-)serialization of polymorphic structs.

Change-Id: Ie6e493a3602b9b8aab3c410c23e73dbf7737c218

diff --git a/src/CommonAPI/InputStream.h b/src/CommonAPI/InputStream.h
index feaa984..6f3444e 100644 (file)
--- a/src/CommonAPI/InputStream.h
+++ b/src/CommonAPI/InputStream.h
@@ -28,48 +28,48 @@
 namespace CommonAPI {
 
 class InputStream {
- public:
-    virtual ~InputStream() { }
+public:
+    virtual ~InputStream() {}
     virtual bool hasError() const = 0;
 
-       virtual InputStream& readValue(bool& boolValue) = 0;
+    virtual InputStream& readValue(bool& boolValue) = 0;
 
-       virtual InputStream& readValue(int8_t& int8Value) = 0;
-       virtual InputStream& readValue(int16_t& int16Value) = 0;
-       virtual InputStream& readValue(int32_t& int32Value) = 0;
-       virtual InputStream& readValue(int64_t& int64Value) = 0;
+    virtual InputStream& readValue(int8_t& int8Value) = 0;
+    virtual InputStream& readValue(int16_t& int16Value) = 0;
+    virtual InputStream& readValue(int32_t& int32Value) = 0;
+    virtual InputStream& readValue(int64_t& int64Value) = 0;
 
-       virtual InputStream& readValue(uint8_t& uint8Value) = 0;
-       virtual InputStream& readValue(uint16_t& uint16Value) = 0;
-       virtual InputStream& readValue(uint32_t& uint32Value) = 0;
-       virtual InputStream& readValue(uint64_t& uint64Value) = 0;
+    virtual InputStream& readValue(uint8_t& uint8Value) = 0;
+    virtual InputStream& readValue(uint16_t& uint16Value) = 0;
+    virtual InputStream& readValue(uint32_t& uint32Value) = 0;
+    virtual InputStream& readValue(uint64_t& uint64Value) = 0;
 
-       virtual InputStream& readValue(float& floatValue) = 0;
-       virtual InputStream& readValue(double& doubleValue) = 0;
+    virtual InputStream& readValue(float& floatValue) = 0;
+    virtual InputStream& readValue(double& doubleValue) = 0;
 
-       virtual InputStream& readValue(std::string& stringValue) = 0;
+    virtual InputStream& readValue(std::string& stringValue) = 0;
 
-       virtual InputStream& readValue(ByteBuffer& byteBufferValue) = 0;
+    virtual InputStream& readValue(ByteBuffer& byteBufferValue) = 0;
 
-       virtual InputStream& readEnumValue(int8_t& int8BackingTypeValue) = 0;
-       virtual InputStream& readEnumValue(int16_t& int16BackingTypeValue) = 0;
-       virtual InputStream& readEnumValue(int32_t& int32BackingTypeValue) = 0;
-       virtual InputStream& readEnumValue(int64_t& int64BackingTypeValue) = 0;
-       virtual InputStream& readEnumValue(uint8_t& uint8BackingTypeValue) = 0;
-       virtual InputStream& readEnumValue(uint16_t& uint16BackingTypeValue) = 0;
-       virtual InputStream& readEnumValue(uint32_t& uint32BackingTypeValue) = 0;
-       virtual InputStream& readEnumValue(uint64_t& uint64BackingTypeValue) = 0;
+    virtual InputStream& readEnumValue(int8_t& int8BackingTypeValue) = 0;
+    virtual InputStream& readEnumValue(int16_t& int16BackingTypeValue) = 0;
+    virtual InputStream& readEnumValue(int32_t& int32BackingTypeValue) = 0;
+    virtual InputStream& readEnumValue(int64_t& int64BackingTypeValue) = 0;
+    virtual InputStream& readEnumValue(uint8_t& uint8BackingTypeValue) = 0;
+    virtual InputStream& readEnumValue(uint16_t& uint16BackingTypeValue) = 0;
+    virtual InputStream& readEnumValue(uint32_t& uint32BackingTypeValue) = 0;
+    virtual InputStream& readEnumValue(uint64_t& uint64BackingTypeValue) = 0;
 
-       template <typename _EnumBackingType, typename _EnumType>
-       inline InputStream& readEnumValue(_EnumType& enumValue);
+    template<typename _EnumBackingType, typename _EnumType>
+    inline InputStream& readEnumValue(_EnumType& enumValue);
 
-       virtual InputStream& readVersionValue(Version& versionValue) = 0;
+    virtual InputStream& readVersionValue(Version& versionValue) = 0;
 
-       virtual void beginReadSerializableStruct(const SerializableStruct& serializableStruct) = 0;
-       virtual void endReadSerializableStruct(const SerializableStruct& serializableStruct) = 0;
+    virtual void beginReadSerializableStruct(const SerializableStruct& serializableStruct) = 0;
+    virtual void endReadSerializableStruct(const SerializableStruct& serializableStruct) = 0;
 
-       virtual void beginReadSerializablePolymorphicStruct(uint32_t& serialId) = 0;
-       virtual void endReadSerializablePolymorphicStruct(const uint32_t& serialId) = 0;
+    virtual void beginReadSerializablePolymorphicStruct(uint32_t& serialId) = 0;
+    virtual void endReadSerializablePolymorphicStruct(const uint32_t& serialId) = 0;
 
     virtual void readSerializableVariant(SerializableVariant& serializableVariant) = 0;
 
@@ -104,77 +104,78 @@ class InputStream {
     virtual void beginReadVectorOfVectors() = 0;
     virtual void beginReadVectorOfMaps() = 0;
 
+    virtual void beginReadVectorOfSerializablePolymorphicStructs() = 0;
+
     virtual bool hasMoreVectorElements() = 0;
     virtual void endReadVector() = 0;
 
-       virtual void beginReadMap() = 0;
-       virtual bool hasMoreMapElements() = 0;
-       virtual void endReadMap() = 0;
-       virtual void beginReadMapElement() = 0;
-       virtual void endReadMapElement() = 0;
+    virtual void beginReadMap() = 0;
+    virtual bool hasMoreMapElements() = 0;
+    virtual void endReadMap() = 0;
+    virtual void beginReadMapElement() = 0;
+    virtual void endReadMapElement() = 0;
 };
 
-template <typename _EnumBackingType, typename _EnumType>
+template<typename _EnumBackingType, typename _EnumType>
 InputStream& InputStream::readEnumValue(_EnumType& enumValue) {
-       _EnumBackingType enumBackingValue;
+    _EnumBackingType enumBackingValue;
 
-       readEnumValue(enumBackingValue);
-       enumValue = static_cast<_EnumType>(enumBackingValue);
+    readEnumValue(enumBackingValue);
+    enumValue = static_cast<_EnumType>(enumBackingValue);
 
-       return *this;
+    return *this;
 }
 
-
 inline InputStream& operator>>(InputStream& inputStream, bool& boolValue) {
-       return inputStream.readValue(boolValue);
+    return inputStream.readValue(boolValue);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, int8_t& int8Value) {
-       return inputStream.readValue(int8Value);
+    return inputStream.readValue(int8Value);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, int16_t& int16Value) {
-       return inputStream.readValue(int16Value);
+    return inputStream.readValue(int16Value);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, int32_t& int32Value) {
-       return inputStream.readValue(int32Value);
+    return inputStream.readValue(int32Value);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, int64_t& int64Value) {
-       return inputStream.readValue(int64Value);
+    return inputStream.readValue(int64Value);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, uint8_t& uint8Value) {
-       return inputStream.readValue(uint8Value);
+    return inputStream.readValue(uint8Value);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, uint16_t& uint16Value) {
-       return inputStream.readValue(uint16Value);
+    return inputStream.readValue(uint16Value);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, uint32_t& uint32Value) {
-       return inputStream.readValue(uint32Value);
+    return inputStream.readValue(uint32Value);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, uint64_t& uint64Value) {
-       return inputStream.readValue(uint64Value);
+    return inputStream.readValue(uint64Value);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, float& floatValue) {
-       return inputStream.readValue(floatValue);
+    return inputStream.readValue(floatValue);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, double& doubleValue) {
-       return inputStream.readValue(doubleValue);
+    return inputStream.readValue(doubleValue);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, std::string& stringValue) {
-       return inputStream.readValue(stringValue);
+    return inputStream.readValue(stringValue);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, Version& versionValue) {
-       return inputStream.readVersionValue(versionValue);
+    return inputStream.readVersionValue(versionValue);
 }
 
 inline InputStream& operator>>(InputStream& inputStream, SerializableStruct& serializableStruct) {
@@ -185,23 +186,25 @@ inline InputStream& operator>>(InputStream& inputStream, SerializableStruct& ser
     return inputStream;
 }
 
-template <typename _SerializablePolymorphicStructType>
-typename std::enable_if<std::is_base_of<SerializablePolymorphicStruct, _SerializablePolymorphicStructType>::value, InputStream>::type&
-operator>>(InputStream& inputStream, std::shared_ptr<_SerializablePolymorphicStructType>& serializablePolymorphicStruct) {
-       uint32_t serialId;
-
-       inputStream.beginReadSerializablePolymorphicStruct(serialId);
-       if (!inputStream.hasError()) {
-               _SerializablePolymorphicStructType* instancePtr = _SerializablePolymorphicStructType::createInstance(serialId);
-               serializablePolymorphicStruct.reset(instancePtr);
-               if (instancePtr != NULL) {
-                       instancePtr->readFromInputStream(inputStream);
-               }
-
-               inputStream.endReadSerializablePolymorphicStruct(serialId);
-       }
+template<typename _SerializablePolymorphicStructType>
+typename std::enable_if<std::is_base_of<SerializablePolymorphicStruct, _SerializablePolymorphicStructType>::value,
+                InputStream>::type&
+operator>>(InputStream& inputStream,
+           std::shared_ptr<_SerializablePolymorphicStructType>& serializablePolymorphicStruct) {
+    uint32_t serialId;
+
+    inputStream.beginReadSerializablePolymorphicStruct(serialId);
+    if (!inputStream.hasError()) {
+        _SerializablePolymorphicStructType* instancePtr = _SerializablePolymorphicStructType::createInstance(serialId);
+        serializablePolymorphicStruct.reset(instancePtr);
+        if (instancePtr != NULL) {
+            instancePtr->readFromInputStream(inputStream);
+        }
+
+        inputStream.endReadSerializablePolymorphicStruct(serialId);
+    }
 
-       return inputStream;
+    return inputStream;
 }
 
 inline InputStream& operator>>(InputStream& inputStream, SerializableVariant& serializableVariant) {
@@ -209,15 +212,14 @@ inline InputStream& operator>>(InputStream& inputStream, SerializableVariant& se
     return inputStream;
 }
 
-
-template <typename _VectorElementType>
+template<typename _VectorElementType>
 class InputStreamGenericTypeVectorHelper {
- public:
+public:
     static void beginReadVector(InputStream& inputStream, const std::vector<_VectorElementType>& vectorValue) {
         doBeginReadVector(inputStream, vectorValue);
     }
 
- private:
+private:
     static inline void doBeginReadVector(InputStream& inputStream, const std::vector<bool>& vectorValue) {
         inputStream.beginReadBoolVector();
     }
@@ -261,46 +263,53 @@ class InputStreamGenericTypeVectorHelper {
         inputStream.beginReadVersionVector();
     }
 
+    template<typename _PointerType,
+             typename = typename std::enable_if<
+                                    std::is_base_of<SerializablePolymorphicStruct, _PointerType>::value>::type>
+    static inline void doBeginReadVector(InputStream& inputStream,
+                                         const std::vector<std::shared_ptr<_PointerType>>& vectorValue) {
+        inputStream.beginReadVectorOfSerializablePolymorphicStructs();
+    }
+
     template<typename _InnerVectorElementType>
-    static inline void doBeginReadVector(InputStream& inputStream, const std::vector<std::vector<_InnerVectorElementType>>& vectorValue) {
+    static inline void doBeginReadVector(InputStream& inputStream,
+                                         const std::vector<std::vector<_InnerVectorElementType>>& vectorValue) {
         inputStream.beginReadVectorOfVectors();
     }
 
     template<typename _InnerKeyType, typename _InnerValueType>
-    static inline void doBeginReadVector(InputStream& inputStream, const std::vector<std::unordered_map<_InnerKeyType, _InnerValueType>>& vectorValue) {
+    static inline void doBeginReadVector(InputStream& inputStream,
+                                         const std::vector<std::unordered_map<_InnerKeyType, _InnerValueType>>& vectorValue) {
         inputStream.beginReadVectorOfMaps();
     }
 };
 
-
-template <typename _VectorElementType, bool _IsSerializableStruct = false>
+template<typename _VectorElementType, bool _IsSerializableStruct = false>
 struct InputStreamSerializableStructVectorHelper: InputStreamGenericTypeVectorHelper<_VectorElementType> {
 };
 
-template <typename _VectorElementType>
+template<typename _VectorElementType>
 struct InputStreamSerializableStructVectorHelper<_VectorElementType, true> {
     static void beginReadVector(InputStream& inputStream, const std::vector<_VectorElementType>& vectorValue) {
         inputStream.beginReadVectorOfSerializableStructs();
     }
 };
 
-
-template <typename _VectorElementType, bool _IsSerializableVariant = false>
+template<typename _VectorElementType, bool _IsSerializableVariant = false>
 struct InputStreamSerializableVariantVectorHelper: InputStreamSerializableStructVectorHelper<_VectorElementType,
-                                                                                             std::is_base_of<SerializableStruct, _VectorElementType>::value> {
+                std::is_base_of<SerializableStruct, _VectorElementType>::value> {
 };
 
-template <typename _VectorElementType>
+template<typename _VectorElementType>
 struct InputStreamSerializableVariantVectorHelper<_VectorElementType, true> {
     static void beginReadVector(InputStream& inputStream, const std::vector<_VectorElementType>& vectorValue) {
         inputStream.beginReadVectorOfSerializableVariants();
     }
 };
 
-
-template <typename _VectorElementType>
+template<typename _VectorElementType>
 struct InputStreamVectorHelper: InputStreamSerializableVariantVectorHelper<_VectorElementType,
-                                                                           std::is_base_of<SerializableVariant, _VectorElementType>::value> {
+                std::is_base_of<SerializableVariant, _VectorElementType>::value> {
 };
 
 /**
@@ -353,7 +362,6 @@ InputStream& operator>>(InputStream& inputStream, std::unordered_map<_KeyType, _
     }
 
     inputStream.endReadMap();
-
     return inputStream;
 }
 

diff --git a/src/CommonAPI/OutputStream.h b/src/CommonAPI/OutputStream.h
index 80a0f0b..92c7cd9 100644 (file)
--- a/src/CommonAPI/OutputStream.h
+++ b/src/CommonAPI/OutputStream.h
@@ -31,10 +31,9 @@ namespace CommonAPI {
 class SerializableVariant;
 
 class TypeOutputStream {
-  public:
+public:
     virtual ~TypeOutputStream() {}
 
-
     virtual void writeBoolType() = 0;
 
     virtual void writeInt8Type() = 0;
@@ -47,7 +46,6 @@ class TypeOutputStream {
     virtual void writeUInt32Type() = 0;
     virtual void writeUInt64Type() = 0;
 
-
     virtual void writeInt8EnumType() = 0;
     virtual void writeInt16EnumType() = 0;
     virtual void writeInt32EnumType() = 0;
@@ -58,7 +56,6 @@ class TypeOutputStream {
     virtual void writeUInt32EnumType() = 0;
     virtual void writeUInt64EnumType() = 0;
 
-
     virtual void writeFloatType() = 0;
     virtual void writeDoubleType() = 0;
 
@@ -80,212 +77,199 @@ class TypeOutputStream {
     virtual std::string retrieveSignature() = 0;
 };
 
-
 template<typename _Type>
 struct TypeWriter;
 
-
 template<typename _Type>
 struct BasicTypeWriter;
 
-
 template<>
 struct BasicTypeWriter<bool> {
-inline static void writeType(TypeOutputStream& typeStream) {
-    typeStream.writeBoolType();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeBoolType();
+    }
 };
 
-
 template<>
 struct BasicTypeWriter<int8_t> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeInt8Type();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeInt8Type();
+    }
 };
 
 template<>
 struct BasicTypeWriter<int16_t> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeInt16Type();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeInt16Type();
+    }
 };
 
 template<>
 struct BasicTypeWriter<int32_t> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeInt32Type();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeInt32Type();
+    }
 };
 
 template<>
 struct BasicTypeWriter<int64_t> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeInt64Type();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeInt64Type();
+    }
 };
 
-
 template<>
 struct BasicTypeWriter<uint8_t> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeUInt8Type();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeUInt8Type();
+    }
 };
 
 template<>
 struct BasicTypeWriter<uint16_t> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeUInt16Type();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeUInt16Type();
+    }
 };
 
 template<>
 struct BasicTypeWriter<uint32_t> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeUInt32Type();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeUInt32Type();
+    }
 };
 
 template<>
 struct BasicTypeWriter<uint64_t> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeUInt64Type();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeUInt64Type();
+    }
 };
 
-
 template<>
 struct BasicTypeWriter<float> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeFloatType();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeFloatType();
+    }
 };
 
 template<>
 struct BasicTypeWriter<double> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeDoubleType();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeDoubleType();
+    }
 };
 
-
 template<>
 struct BasicTypeWriter<std::string> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeStringType();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeStringType();
+    }
 };
 
 template<>
 struct BasicTypeWriter<CommonAPI::ByteBuffer> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeByteBufferType();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeByteBufferType();
+    }
 };
 
 template<>
 struct BasicTypeWriter<CommonAPI::Version> {
-inline static void writeType (TypeOutputStream& typeStream) {
-    typeStream.writeVersionType();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeVersionType();
+    }
 };
 
-
 template<typename _VectorElementType>
 struct BasicTypeWriter<std::vector<_VectorElementType>> {
-inline static void writeType(TypeOutputStream& typeStream) {
-    typeStream.beginWriteVectorType();
-    TypeWriter<_VectorElementType>::writeType(typeStream);
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.beginWriteVectorType();
+        TypeWriter<_VectorElementType>::writeType(typeStream);
+    }
 };
 
-
 template<typename _KeyType, typename _ValueType>
 struct BasicTypeWriter<std::unordered_map<_KeyType, _ValueType>> {
-inline static void writeType(TypeOutputStream& typeStream) {
-    typeStream.beginWriteMapType();
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.beginWriteMapType();
 
-    BasicTypeWriter<_KeyType>::writeType(typeStream);
-    BasicTypeWriter<_ValueType>::writeType(typeStream);
+        BasicTypeWriter<_KeyType>::writeType(typeStream);
+        BasicTypeWriter<_ValueType>::writeType(typeStream);
 
-    typeStream.endWriteMapType();
-}
+        typeStream.endWriteMapType();
+    }
 };
 
-
 template<typename _Type, bool _IsStructType = false>
 struct StructTypeWriter: public BasicTypeWriter<_Type> {
 };
 
-
 template<typename _Type>
 struct StructTypeWriter<_Type, true> {
-inline static void writeType(TypeOutputStream& typeStream) {
-    typeStream.beginWriteStructType();
-    _Type::writeToTypeOutputStream(typeStream);
-    typeStream.endWriteStructType();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.beginWriteStructType();
+        _Type::writeToTypeOutputStream(typeStream);
+        typeStream.endWriteStructType();
+    }
 };
 
-
 template<typename _Type, bool _IsVariantType = false>
 struct VariantTypeWriter: public StructTypeWriter<_Type, std::is_base_of<SerializableStruct, _Type>::value> {
 };
 
 template<typename _Type>
 struct VariantTypeWriter<_Type, true> {
-inline static void writeType(TypeOutputStream& typeStream) {
-    typeStream.writeVariantType();
-}
+    inline static void writeType(TypeOutputStream& typeStream) {
+        typeStream.writeVariantType();
+    }
 };
 
-
 template<typename _Type>
-struct TypeWriter: public VariantTypeWriter<_Type, std::is_base_of<SerializableVariant, _Type>::value>{};
-
-
+struct TypeWriter: public VariantTypeWriter<_Type, std::is_base_of<SerializableVariant, _Type>::value> {
+};
 
 class OutputStream {
- public:
-    virtual ~OutputStream() {}
+public:
+    virtual ~OutputStream() {
+    }
     virtual bool hasError() const = 0;
 
-       virtual OutputStream& writeValue(const bool& boolValue) = 0;
+    virtual OutputStream& writeValue(const bool& boolValue) = 0;
 
-       virtual OutputStream& writeValue(const int8_t& int8Value) = 0;
-       virtual OutputStream& writeValue(const int16_t& int16Value) = 0;
-       virtual OutputStream& writeValue(const int32_t& int32Value) = 0;
-       virtual OutputStream& writeValue(const int64_t& int64Value) = 0;
+    virtual OutputStream& writeValue(const int8_t& int8Value) = 0;
+    virtual OutputStream& writeValue(const int16_t& int16Value) = 0;
+    virtual OutputStream& writeValue(const int32_t& int32Value) = 0;
+    virtual OutputStream& writeValue(const int64_t& int64Value) = 0;
 
-       virtual OutputStream& writeValue(const uint8_t& uint8Value) = 0;
-       virtual OutputStream& writeValue(const uint16_t& uint16Value) = 0;
-       virtual OutputStream& writeValue(const uint32_t& uint32Value) = 0;
-       virtual OutputStream& writeValue(const uint64_t& uint64Value) = 0;
+    virtual OutputStream& writeValue(const uint8_t& uint8Value) = 0;
+    virtual OutputStream& writeValue(const uint16_t& uint16Value) = 0;
+    virtual OutputStream& writeValue(const uint32_t& uint32Value) = 0;
+    virtual OutputStream& writeValue(const uint64_t& uint64Value) = 0;
 
-       virtual OutputStream& writeValue(const float& floatValue) = 0;
-       virtual OutputStream& writeValue(const double& doubleValue) = 0;
+    virtual OutputStream& writeValue(const float& floatValue) = 0;
+    virtual OutputStream& writeValue(const double& doubleValue) = 0;
 
-       virtual OutputStream& writeValue(const std::string& stringValue) = 0;
+    virtual OutputStream& writeValue(const std::string& stringValue) = 0;
 
-       virtual OutputStream& writeValue(const ByteBuffer& byteBufferValue) = 0;
+    virtual OutputStream& writeValue(const ByteBuffer& byteBufferValue) = 0;
 
-       virtual OutputStream& writeEnumValue(const int8_t& int8BackingTypeValue) = 0;
-       virtual OutputStream& writeEnumValue(const int16_t& int16BackingTypeValue) = 0;
-       virtual OutputStream& writeEnumValue(const int32_t& int32BackingTypeValue) = 0;
-       virtual OutputStream& writeEnumValue(const int64_t& int64BackingTypeValue) = 0;
-       virtual OutputStream& writeEnumValue(const uint8_t& uint8BackingTypeValue) = 0;
-       virtual OutputStream& writeEnumValue(const uint16_t& uint16BackingTypeValue) = 0;
-       virtual OutputStream& writeEnumValue(const uint32_t& uint32BackingTypeValue) = 0;
-       virtual OutputStream& writeEnumValue(const uint64_t& uint64BackingTypeValue) = 0;
+    virtual OutputStream& writeEnumValue(const int8_t& int8BackingTypeValue) = 0;
+    virtual OutputStream& writeEnumValue(const int16_t& int16BackingTypeValue) = 0;
+    virtual OutputStream& writeEnumValue(const int32_t& int32BackingTypeValue) = 0;
+    virtual OutputStream& writeEnumValue(const int64_t& int64BackingTypeValue) = 0;
+    virtual OutputStream& writeEnumValue(const uint8_t& uint8BackingTypeValue) = 0;
+    virtual OutputStream& writeEnumValue(const uint16_t& uint16BackingTypeValue) = 0;
+    virtual OutputStream& writeEnumValue(const uint32_t& uint32BackingTypeValue) = 0;
+    virtual OutputStream& writeEnumValue(const uint64_t& uint64BackingTypeValue) = 0;
 
-       virtual OutputStream& writeVersionValue(const Version& versionValue) = 0;
+    virtual OutputStream& writeVersionValue(const Version& versionValue) = 0;
 
-       virtual void beginWriteSerializableStruct(const SerializableStruct& serializableStruct) = 0;
-       virtual void endWriteSerializableStruct(const SerializableStruct& serializableStruct) = 0;
+    virtual void beginWriteSerializableStruct(const SerializableStruct& serializableStruct) = 0;
+    virtual void endWriteSerializableStruct(const SerializableStruct& serializableStruct) = 0;
 
-       virtual void beginWriteSerializablePolymorphicStruct(const std::shared_ptr<SerializablePolymorphicStruct>& serializableStruct) = 0;
-       virtual void endWriteSerializablePolymorphicStruct(const std::shared_ptr<SerializablePolymorphicStruct>& serializableStruct) = 0;
+    virtual void beginWriteSerializablePolymorphicStruct(const std::shared_ptr<SerializablePolymorphicStruct>& serializableStruct) = 0;
+    virtual void endWriteSerializablePolymorphicStruct(const std::shared_ptr<SerializablePolymorphicStruct>& serializableStruct) = 0;
 
     virtual void beginWriteSerializableVariant(const SerializableVariant& serializableVariant) = 0;
     virtual void endWriteSerializableVariant(const SerializableVariant& serializableVariant) = 0;
@@ -319,72 +303,75 @@ class OutputStream {
     virtual void beginWriteVectorOfVectors(uint32_t sizeOfVector) = 0;
     virtual void beginWriteVectorOfMaps(uint32_t sizeOfVector) = 0;
 
+    virtual void beginWriteVectorOfSerializablePolymorphicStructs(uint32_t sizeOfVector) = 0;
+
     virtual void endWriteVector() = 0;
 
-       virtual void beginWriteMap(size_t elementCount) = 0;
-       virtual void endWriteMap() = 0;
-       virtual void beginWriteMapElement() = 0;
-       virtual void endWriteMapElement() = 0;
+    virtual void beginWriteMap(size_t elementCount) = 0;
+    virtual void endWriteMap() = 0;
+    virtual void beginWriteMapElement() = 0;
+    virtual void endWriteMapElement() = 0;
 
-       virtual bool writeRawData(const char* rawDataPtr, const size_t sizeInByte) = 0;
+    virtual bool writeRawData(const char* rawDataPtr, const size_t sizeInByte) = 0;
 };
 
-
 inline OutputStream& operator<<(OutputStream& outputStream, const bool& boolValue) {
-       return outputStream.writeValue(boolValue);
+    return outputStream.writeValue(boolValue);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const int8_t& int8Value) {
-       return outputStream.writeValue(int8Value);
+    return outputStream.writeValue(int8Value);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const int16_t& int16Value) {
-       return outputStream.writeValue(int16Value);
+    return outputStream.writeValue(int16Value);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const int32_t& int32Value) {
-       return outputStream.writeValue(int32Value);
+    return outputStream.writeValue(int32Value);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const int64_t& int64Value) {
-       return outputStream.writeValue(int64Value);
+    return outputStream.writeValue(int64Value);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const uint8_t& uint8Value) {
-       return outputStream.writeValue(uint8Value);
+    return outputStream.writeValue(uint8Value);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const uint16_t& uint16Value) {
-       return outputStream.writeValue(uint16Value);
+    return outputStream.writeValue(uint16Value);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const uint32_t& uint32Value) {
-       return outputStream.writeValue(uint32Value);
+    return outputStream.writeValue(uint32Value);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const uint64_t& uint64Value) {
-       return outputStream.writeValue(uint64Value);
+    return outputStream.writeValue(uint64Value);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const float& floatValue) {
-       return outputStream.writeValue(floatValue);
+    return outputStream.writeValue(floatValue);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const double& doubleValue) {
-       return outputStream.writeValue(doubleValue);
+    return outputStream.writeValue(doubleValue);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const std::string& stringValue) {
-       return outputStream.writeValue(stringValue);
+    return outputStream.writeValue(stringValue);
 }
 
 inline OutputStream& operator<<(OutputStream& outputStream, const Version& versionValue) {
-       return outputStream.writeVersionValue(versionValue);
+    return outputStream.writeVersionValue(versionValue);
 }
 
-template <typename _SerializablePolymorphicStructType>
-typename std::enable_if<std::is_base_of<SerializablePolymorphicStruct, _SerializablePolymorphicStructType>::value, OutputStream>::type&
-operator<<(OutputStream& outputStream, const std::shared_ptr<_SerializablePolymorphicStructType>& serializablePolymorphicStruct) {
+template<typename _SerializablePolymorphicStructType>
+typename std::enable_if<std::is_base_of<SerializablePolymorphicStruct, _SerializablePolymorphicStructType>::value,
+                OutputStream>::type&
+operator<<(OutputStream& outputStream,
+           const std::shared_ptr<_SerializablePolymorphicStructType>& serializablePolymorphicStruct) {
     outputStream.beginWriteSerializablePolymorphicStruct(serializablePolymorphicStruct);
     serializablePolymorphicStruct->writeToOutputStream(outputStream);
     outputStream.endWriteSerializablePolymorphicStruct(serializablePolymorphicStruct);
@@ -408,15 +395,14 @@ inline OutputStream& operator<<(OutputStream& outputStream, const SerializableVa
     return outputStream;
 }
 
-
-template <typename _VectorElementType>
+template<typename _VectorElementType>
 class OutStreamGenericVectorHelper {
- public:
+public:
     static void beginWriteVector(OutputStream& outputStream, const std::vector<_VectorElementType>& vectorValue) {
         doBeginWriteVector(outputStream, vectorValue);
     }
 
- private:
+private:
     static inline void doBeginWriteVector(OutputStream& outputStream, const std::vector<bool>& vectorValue) {
         outputStream.beginWriteBoolVector(vectorValue.size());
     }
@@ -460,49 +446,56 @@ class OutStreamGenericVectorHelper {
         outputStream.beginWriteVersionVector(vectorValue.size());
     }
 
+    template<typename _PointerType,
+             typename = typename std::enable_if<
+                                    std::is_base_of<SerializablePolymorphicStruct, _PointerType>::value>::type>
+    static inline void doBeginWriteVector(OutputStream& outputStream,
+                                          const std::vector<std::shared_ptr<_PointerType>>& vectorValue) {
+        outputStream.beginWriteVectorOfSerializablePolymorphicStructs(vectorValue.size());
+    }
+
     template<typename _InnerVectorElementType>
-    static inline void doBeginWriteVector(OutputStream& outputStream, const std::vector<std::vector<_InnerVectorElementType>>& vectorValue) {
+    static inline void doBeginWriteVector(OutputStream& outputStream,
+                                          const std::vector<std::vector<_InnerVectorElementType>>& vectorValue) {
         outputStream.beginWriteVectorOfVectors(vectorValue.size());
     }
 
     template<typename _InnerKeyType, typename _InnerValueType>
-    static inline void doBeginWriteVector(OutputStream& outputStream, const std::vector<std::unordered_map<_InnerKeyType, _InnerValueType>>& vectorValue) {
+    static inline void doBeginWriteVector(OutputStream& outputStream,
+                                          const std::vector<std::unordered_map<_InnerKeyType, _InnerValueType>>& vectorValue) {
         outputStream.beginWriteVectorOfMaps(vectorValue.size());
     }
 };
 
-
-template <typename _VectorElementType, bool _IsSerializableStruct = false>
+template<typename _VectorElementType, bool _IsSerializableStruct = false>
 struct OutputStreamSerializableStructVectorHelper: public OutStreamGenericVectorHelper<_VectorElementType> {
 };
 
-template <typename _VectorElementType>
+template<typename _VectorElementType>
 struct OutputStreamSerializableStructVectorHelper<_VectorElementType, true> {
     static void beginWriteVector(OutputStream& outputStream, const std::vector<_VectorElementType>& vectorValue) {
         outputStream.beginWriteVectorOfSerializableStructs(vectorValue.size());
     }
 };
 
-
-template <typename _VectorElementType, bool _IsSerializableVariant = false>
-struct OutputStreamSerializableVariantVectorHelper: public OutputStreamSerializableStructVectorHelper<_VectorElementType,
-                                                                                                      std::is_base_of<SerializableStruct, _VectorElementType>::value> {
+template<typename _VectorElementType, bool _IsSerializableVariant = false>
+struct OutputStreamSerializableVariantVectorHelper: public OutputStreamSerializableStructVectorHelper<
+                _VectorElementType,
+                std::is_base_of<SerializableStruct, _VectorElementType>::value> {
 };
 
-template <typename _VectorElementType>
+template<typename _VectorElementType>
 struct OutputStreamSerializableVariantVectorHelper<_VectorElementType, true> {
     static void beginWriteVector(OutputStream& outputStream, const std::vector<_VectorElementType>& vectorValue) {
         outputStream.beginWriteVectorOfSerializableVariants(vectorValue.size());
     }
 };
 
-
-template <typename _VectorElementType>
+template<typename _VectorElementType>
 struct OutputStreamVectorHelper: OutputStreamSerializableVariantVectorHelper<_VectorElementType,
-                                                                             std::is_base_of<SerializableVariant, _VectorElementType>::value> {
+                std::is_base_of<SerializableVariant, _VectorElementType>::value> {
 };
 
-
 /**
  * Handles all writing of vectors to a given #OutputStream. The given vector may contain any types that are
  * defined as basic types within the context of CommonAPI, as well as any types derived from those basic types.
@@ -548,7 +541,6 @@ OutputStream& operator<<(OutputStream& outputStream,
     }
 
     outputStream.endWriteMap();
-
     return outputStream;
 }