summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorStefan Laner <laner@itestra.de>2013-10-24 19:58:11 +0200
committerPhilip Rauwolf <rauwolf@itestra.de>2013-10-29 17:37:29 +0100
commit7d9a0a36019cfb6dfac854e4b5ff6a0ad632ac98 (patch)
tree953e58f80f5bc1848148fea9982e8472dfd24c16
parent9beb2a82f63afc8f48f4be651e0c8d124ad6f237 (diff)
downloadgenivi-common-api-runtime-7d9a0a36019cfb6dfac854e4b5ff6a0ad632ac98.tar.gz
Fixed (de-)serialization of polymorphic structs.
Change-Id: Ie6e493a3602b9b8aab3c410c23e73dbf7737c218
-rw-r--r--src/CommonAPI/InputStream.h182
-rw-r--r--src/CommonAPI/OutputStream.h290
2 files changed, 236 insertions, 236 deletions
diff --git a/src/CommonAPI/InputStream.h b/src/CommonAPI/InputStream.h
index feaa984..6f3444e 100644
--- 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
--- 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;
}