From 2138491ee5d6583ead9af2f3594113139e16a0b9 Mon Sep 17 00:00:00 2001 From: Martchus Date: Sun, 4 Jul 2021 22:17:57 +0200 Subject: [PATCH] WIP --- .../binaryserializationcodegenerator.cpp | 62 ++++++++++++------- generator/binaryserializationcodegenerator.h | 2 +- generator/codegenerator.cpp | 11 ++-- generator/codegenerator.h | 3 +- generator/jsonserializationcodegenerator.cpp | 25 +++----- generator/jsonserializationcodegenerator.h | 2 +- generator/serializationcodegenerator.cpp | 40 +++++++----- generator/serializationcodegenerator.h | 11 ++-- generator/tests/morestructs.h | 5 +- lib/binary/reflector-boosthana.h | 4 +- lib/binary/reflector-chronoutilities.h | 6 +- lib/binary/reflector.h | 11 ++-- lib/binary/serializable.h | 24 +++---- lib/tests/binaryreflector.cpp | 11 +++- lib/tests/traits.cpp | 27 +++++++- lib/versioning.h | 23 +++++++ 16 files changed, 176 insertions(+), 91 deletions(-) diff --git a/generator/binaryserializationcodegenerator.cpp b/generator/binaryserializationcodegenerator.cpp index 216c245..d89e278 100644 --- a/generator/binaryserializationcodegenerator.cpp +++ b/generator/binaryserializationcodegenerator.cpp @@ -39,30 +39,25 @@ BinarySerializationCodeGenerator::BinarySerializationCodeGenerator(CodeFactory & } /*! - * \brief Returns the qualified name of the specified \a record if it is considered relevant. + * \brief Checks whether \a possiblyRelevantClass is actually relevant. */ -string BinarySerializationCodeGenerator::qualifiedNameIfRelevant(clang::CXXRecordDecl *record) const +void BinarySerializationCodeGenerator::computeRelevantClass(RelevantClass &possiblyRelevantClass) const { - const string qualifiedName(record->getQualifiedNameAsString()); - switch (isQualifiedNameIfRelevant(record, qualifiedName)) { - case IsRelevant::Yes: - return qualifiedName; - case IsRelevant::No: - return string(); - default:; + SerializationCodeGenerator::computeRelevantClass(possiblyRelevantClass); + if (possiblyRelevantClass.isRelevant != IsRelevant::Maybe) { + return; } // consider all classes specified via "--additional-classes" argument relevant if (!m_options.additionalClassesArg.isPresent()) { - return string(); + return; } - for (const char *className : m_options.additionalClassesArg.values()) { - if (className == qualifiedName) { - return qualifiedName; + for (const char *const className : m_options.additionalClassesArg.values()) { + if (className == possiblyRelevantClass.qualifiedName) { + possiblyRelevantClass.isRelevant = IsRelevant::Yes; + return; } } - - return string(); } /// \brief The RetrieveIntegerLiteralFromDeclaratorDecl struct is used to traverse a variable declaration to get the integer value. @@ -250,9 +245,19 @@ void BinarySerializationCodeGenerator::generate(std::ostream &os) const // print writeCustomType method os << "template <> " << visibility << " void writeCustomType<::" << relevantClass.qualifiedName - << ">(BinarySerializer &serializer, const ::" << relevantClass.qualifiedName - << " &customObject, BinaryVersion version)\n{\n" - " // write base classes\n"; + << ">(BinarySerializer &serializer, const ::" << relevantClass.qualifiedName << " &customObject, BinaryVersion version)\n{\n"; + if (!relevantClass.relevantBase.empty()) { + os << " // write version\n" + " using V = Versioning<" + << relevantClass.relevantBase + << ">;\n" + " if constexpr (V::enabled) {\n" + " serializer.writeVariableLengthUIntBE(V::applyDefault(version));\n" + " } else {\n" + " (void)version;\n" + " }\n"; + } + os << " // write base classes\n"; for (const RelevantClass *baseClass : relevantBases) { os << " serializer.write(static_castqualifiedName << " &>(customObject), version);\n"; } @@ -260,7 +265,7 @@ void BinarySerializationCodeGenerator::generate(std::ostream &os) const auto mt = MemberTracking(); for (clang::Decl *const decl : relevantClass.record->decls()) { // check static member variables for version markers - if (mt.checkForVersionMarker(decl)) { + if (mt.checkForVersionMarker(decl)) { continue; } @@ -301,17 +306,25 @@ void BinarySerializationCodeGenerator::generate(std::ostream &os) const // print readCustomType method mt = MemberTracking(); - os << "template <> " << visibility << " void readCustomType<::" << relevantClass.qualifiedName - << ">(BinaryDeserializer &deserializer, ::" << relevantClass.qualifiedName - << " &customObject)\n{\n" - " // read base classes\n"; + os << "template <> " << visibility << " BinaryVersion readCustomType<::" << relevantClass.qualifiedName + << ">(BinaryDeserializer &deserializer, ::" << relevantClass.qualifiedName << " &customObject)\n{\n"; + if (!relevantClass.relevantBase.empty()) { + os << " // read version\n" + " auto version = BinaryVersion();\n" + " if constexpr (Versioning<" + << relevantClass.relevantBase + << ">::enabled) {\n" + " version = deserializer.readVariableLengthUIntBE();\n" + " }\n"; + } + os << " // read base classes\n"; for (const RelevantClass *baseClass : relevantBases) { os << " deserializer.read(static_cast<::" << baseClass->qualifiedName << " &>(customObject));\n"; } os << " // read members\n"; for (clang::Decl *const decl : relevantClass.record->decls()) { // check static member variables for version markers - if (mt.checkForVersionMarker(decl)) { + if (mt.checkForVersionMarker(decl)) { continue; } @@ -339,6 +352,7 @@ void BinarySerializationCodeGenerator::generate(std::ostream &os) const if (relevantBases.empty() && !mt.membersWritten) { os << " (void)deserializer;\n (void)customObject;\n"; } + os << " return version;\n"; os << "}\n\n"; } diff --git a/generator/binaryserializationcodegenerator.h b/generator/binaryserializationcodegenerator.h index 2563db8..4bbc851 100644 --- a/generator/binaryserializationcodegenerator.h +++ b/generator/binaryserializationcodegenerator.h @@ -27,7 +27,7 @@ public: void generate(std::ostream &os) const override; protected: - std::string qualifiedNameIfRelevant(clang::CXXRecordDecl *record) const override; + void computeRelevantClass(RelevantClass &possiblyRelevantClass) const override; const Options &m_options; }; diff --git a/generator/codegenerator.cpp b/generator/codegenerator.cpp index 0694ae6..f2f3acc 100644 --- a/generator/codegenerator.cpp +++ b/generator/codegenerator.cpp @@ -44,17 +44,18 @@ bool CodeGenerator::isOnlyIncluded(const clang::Decl *declaration) const /*! * \brief Returns whether the specified \a record inherits from an instantiation of the specified \a templateClass. + * \returns Returns the relevant base class if that's the case and otherwise nullptr. * \remarks The specified \a record must be defined (not only forward-declared). */ -bool CodeGenerator::inheritsFromInstantiationOf(clang::CXXRecordDecl *const record, const char *const templateClass) +clang::CXXBaseSpecifier *CodeGenerator::inheritsFromInstantiationOf(clang::CXXRecordDecl *const record, const char *const templateClass) { - for (const clang::CXXBaseSpecifier &base : record->bases()) { - const clang::CXXRecordDecl *const baseDecl = base.getType()->getAsCXXRecordDecl(); + for (clang::CXXBaseSpecifier &base : record->bases()) { + clang::CXXRecordDecl *const baseDecl = base.getType()->getAsCXXRecordDecl(); if (baseDecl && baseDecl->getQualifiedNameAsString() == templateClass) { - return true; + return &base; } } - return false; + return nullptr; } } // namespace ReflectiveRapidJSON diff --git a/generator/codegenerator.h b/generator/codegenerator.h index 0c5de9d..a206b87 100644 --- a/generator/codegenerator.h +++ b/generator/codegenerator.h @@ -8,6 +8,7 @@ namespace clang { class Decl; class CXXRecordDecl; +class CXXBaseSpecifier; class SourceManager; } // namespace clang @@ -32,7 +33,7 @@ protected: CodeFactory &factory() const; void lazyInitializeSourceManager() const; bool isOnlyIncluded(const clang::Decl *declaration) const; - static bool inheritsFromInstantiationOf(clang::CXXRecordDecl *record, const char *templateClass); + static clang::CXXBaseSpecifier *inheritsFromInstantiationOf(clang::CXXRecordDecl *record, const char *templateClass); private: CodeFactory &m_factory; diff --git a/generator/jsonserializationcodegenerator.cpp b/generator/jsonserializationcodegenerator.cpp index 3f90657..700d96d 100644 --- a/generator/jsonserializationcodegenerator.cpp +++ b/generator/jsonserializationcodegenerator.cpp @@ -35,30 +35,25 @@ JsonSerializationCodeGenerator::JsonSerializationCodeGenerator(CodeFactory &fact } /*! - * \brief Returns the qualified name of the specified \a record if it is considered relevant. + * \brief Checks whether \a possiblyRelevantClass is actually relevant. */ -string JsonSerializationCodeGenerator::qualifiedNameIfRelevant(clang::CXXRecordDecl *record) const +void JsonSerializationCodeGenerator::computeRelevantClass(RelevantClass &possiblyRelevantClass) const { - const string qualifiedName(record->getQualifiedNameAsString()); - switch (isQualifiedNameIfRelevant(record, qualifiedName)) { - case IsRelevant::Yes: - return qualifiedName; - case IsRelevant::No: - return string(); - default:; + SerializationCodeGenerator::computeRelevantClass(possiblyRelevantClass); + if (possiblyRelevantClass.isRelevant != IsRelevant::Maybe) { + return; } // consider all classes specified via "--additional-classes" argument relevant if (!m_options.additionalClassesArg.isPresent()) { - return string(); + return; } - for (const char *className : m_options.additionalClassesArg.values()) { - if (className == qualifiedName) { - return qualifiedName; + for (const char *const className : m_options.additionalClassesArg.values()) { + if (className == possiblyRelevantClass.qualifiedName) { + possiblyRelevantClass.isRelevant = IsRelevant::Yes; + return; } } - - return string(); } /*! diff --git a/generator/jsonserializationcodegenerator.h b/generator/jsonserializationcodegenerator.h index 67e8a19..f94024a 100644 --- a/generator/jsonserializationcodegenerator.h +++ b/generator/jsonserializationcodegenerator.h @@ -27,7 +27,7 @@ public: void generate(std::ostream &os) const override; protected: - std::string qualifiedNameIfRelevant(clang::CXXRecordDecl *record) const override; + void computeRelevantClass(RelevantClass &possiblyRelevantClass) const override; const Options &m_options; }; diff --git a/generator/serializationcodegenerator.cpp b/generator/serializationcodegenerator.cpp index b7fffe2..b76029a 100644 --- a/generator/serializationcodegenerator.cpp +++ b/generator/serializationcodegenerator.cpp @@ -66,12 +66,12 @@ void SerializationCodeGenerator::addDeclaration(clang::Decl *decl) } } -SerializationCodeGenerator::IsRelevant SerializationCodeGenerator::isQualifiedNameIfRelevant( - clang::CXXRecordDecl *record, const std::string &qualifiedName) const +void SerializationCodeGenerator::computeRelevantClass(RelevantClass &possiblyRelevantClass) const { // skip all classes which are only forward-declared - if (!record->isCompleteDefinition()) { - return IsRelevant::No; + if (!possiblyRelevantClass.record->isCompleteDefinition()) { + possiblyRelevantClass.isRelevant = IsRelevant::No; + return; } // consider all classes for which a specialization of the "AdaptedJsonSerializable" struct is available @@ -80,31 +80,39 @@ SerializationCodeGenerator::IsRelevant SerializationCodeGenerator::isQualifiedNa if (isOnlyIncluded(adaptionRecord.record)) { continue; } - if (adaptionRecord.qualifiedName == qualifiedName) { - return IsRelevant::Yes; + if (adaptionRecord.qualifiedName == possiblyRelevantClass.qualifiedName) { + possiblyRelevantClass.isRelevant = IsRelevant::Yes; + return; } } // skip all classes which are only included - if (isOnlyIncluded(record)) { - return IsRelevant::No; + if (isOnlyIncluded(possiblyRelevantClass.record)) { + possiblyRelevantClass.isRelevant = IsRelevant::No; + return; } // consider all classes inheriting from an instantiation of "JsonSerializable" relevant - if (inheritsFromInstantiationOf(record, m_qualifiedNameOfRecords)) { - return IsRelevant::Yes; + if (const auto *const relevantBase = inheritsFromInstantiationOf(possiblyRelevantClass.record, m_qualifiedNameOfRecords)) { + cerr << "record: " << possiblyRelevantClass.qualifiedName << '\n'; + for (const clang::CXXBaseSpecifier base : possiblyRelevantClass.record->bases()) { + cerr << "base: " << base.getType().getAsString() << '\n'; + } + cerr << "relevant base: " << relevantBase->getType().getAsString(); + possiblyRelevantClass.relevantBase = relevantBase->getType().getAsString(); + possiblyRelevantClass.isRelevant = IsRelevant::Yes; + return; } - - return IsRelevant::Maybe; } std::vector SerializationCodeGenerator::findRelevantClasses() const { std::vector relevantClasses; - for (clang::CXXRecordDecl *record : m_records) { - string qualifiedName(qualifiedNameIfRelevant(record)); - if (!qualifiedName.empty()) { - relevantClasses.emplace_back(move(qualifiedName), record); + for (clang::CXXRecordDecl *const record : m_records) { + auto &relevantClass = relevantClasses.emplace_back(record->getQualifiedNameAsString(), record); + computeRelevantClass(relevantClass); + if (relevantClass.isRelevant != IsRelevant::Yes) { + relevantClasses.pop_back(); } } return relevantClasses; diff --git a/generator/serializationcodegenerator.h b/generator/serializationcodegenerator.h index ba171c3..23a3236 100644 --- a/generator/serializationcodegenerator.h +++ b/generator/serializationcodegenerator.h @@ -5,6 +5,8 @@ #include +#include + namespace ReflectiveRapidJSON { std::ostream &operator<<(std::ostream &os, llvm::StringRef str); @@ -15,11 +17,14 @@ std::ostream &operator<<(std::ostream &os, llvm::StringRef str); */ class SerializationCodeGenerator : public CodeGenerator { public: + enum class IsRelevant { Yes, No, Maybe }; struct RelevantClass { explicit RelevantClass(std::string &&qualifiedName, clang::CXXRecordDecl *record); std::string qualifiedName; - clang::CXXRecordDecl *record; + std::string relevantBase; + clang::CXXRecordDecl *record = nullptr; + IsRelevant isRelevant = IsRelevant::Maybe; }; SerializationCodeGenerator(CodeFactory &factory); @@ -27,9 +32,7 @@ public: void addDeclaration(clang::Decl *decl) override; protected: - enum class IsRelevant { Yes, No, Maybe }; - IsRelevant isQualifiedNameIfRelevant(clang::CXXRecordDecl *record, const std::string &qualifiedName) const; - virtual std::string qualifiedNameIfRelevant(clang::CXXRecordDecl *record) const = 0; + virtual void computeRelevantClass(RelevantClass &possiblyRelevantClass) const; std::vector findRelevantClasses() const; static std::vector findRelevantBaseClasses( const RelevantClass &relevantClass, const std::vector &relevantBases); diff --git a/generator/tests/morestructs.h b/generator/tests/morestructs.h index 1b5f529..bac107c 100644 --- a/generator/tests/morestructs.h +++ b/generator/tests/morestructs.h @@ -74,7 +74,7 @@ struct PointerStruct : public BinarySerializable { * \brief The PointerStruct struct is used to test the behavior of the binary (de)serialization with smart pointer. */ // clang-format off -struct VersionedStruct : public BinarySerializable { +struct VersionedStruct : public BinarySerializable { std::uint32_t a, b; until_version(2): @@ -82,6 +82,9 @@ until_version(2): as_of_version(3): std::uint32_t e, f; + +as_of_version(4): + std::uint32_t g; }; // clang-format on diff --git a/lib/binary/reflector-boosthana.h b/lib/binary/reflector-boosthana.h index 4b455cc..bb9f0dc 100644 --- a/lib/binary/reflector-boosthana.h +++ b/lib/binary/reflector-boosthana.h @@ -24,15 +24,17 @@ namespace ReflectiveRapidJSON { namespace BinaryReflector { -template > *> void readCustomType(BinaryDeserializer &deserializer, Type &customType) +template > *> BinaryVersion readCustomType(BinaryDeserializer &deserializer, Type &customType) { boost::hana::for_each( boost::hana::keys(customType), [&deserializer, &customType](auto key) { deserializer.read(boost::hana::at_key(customType, key)); }); + return 0; } template > *> void writeCustomType(BinarySerializer &serializer, const Type &customType, BinaryVersion version) { + CPP_UTILITIES_UNUSED(version) boost::hana::for_each( boost::hana::keys(customType), [&serializer, &customType](auto key) { serializer.write(boost::hana::at_key(customType, key)); }); } diff --git a/lib/binary/reflector-chronoutilities.h b/lib/binary/reflector-chronoutilities.h index 00f153a..dce7029 100644 --- a/lib/binary/reflector-chronoutilities.h +++ b/lib/binary/reflector-chronoutilities.h @@ -16,9 +16,10 @@ namespace ReflectiveRapidJSON { namespace BinaryReflector { -template <> inline void readCustomType(BinaryDeserializer &deserializer, CppUtilities::DateTime &dateTime) +template <> inline BinaryVersion readCustomType(BinaryDeserializer &deserializer, CppUtilities::DateTime &dateTime) { deserializer.read(dateTime.ticks()); + return 0; } template <> @@ -28,9 +29,10 @@ inline void writeCustomType(BinarySerializer &serializer serializer.write(dateTime.totalTicks()); } -template <> inline void readCustomType(BinaryDeserializer &deserializer, CppUtilities::TimeSpan &timeSpan) +template <> inline BinaryVersion readCustomType(BinaryDeserializer &deserializer, CppUtilities::TimeSpan &timeSpan) { deserializer.read(timeSpan.ticks()); + return 0; } template <> diff --git a/lib/binary/reflector.h b/lib/binary/reflector.h index bfc72af..4adba3d 100644 --- a/lib/binary/reflector.h +++ b/lib/binary/reflector.h @@ -35,7 +35,7 @@ template struct AdaptedBinarySerializable : public Traits::Bool struct BinarySerializable; +template struct BinarySerializable; /*! * \brief The BinaryReflector namespace contains BinaryReader and BinaryWriter for automatic binary (de)serialization. @@ -52,7 +52,8 @@ template using IsCustomType = Traits::Not>; class BinaryDeserializer; class BinarySerializer; -template > * = nullptr> void readCustomType(BinaryDeserializer &deserializer, Type &customType); +template > * = nullptr> +BinaryVersion readCustomType(BinaryDeserializer &deserializer, Type &customType); template > * = nullptr> void writeCustomType(BinarySerializer &serializer, const Type &customType, BinaryVersion version = 0); @@ -74,7 +75,7 @@ public: void read(Type &iteratable); template > * = nullptr> void read(Type &enumValue); template > * = nullptr> void read(Type &variant); - template > * = nullptr> void read(Type &customType); + template > * = nullptr> BinaryVersion read(Type &customType); private: std::unordered_map m_pointer; @@ -211,9 +212,9 @@ template > *> void BinaryDeseria Detail::readVariantValueByRuntimeIndex(readByte(), variant, *this); } -template > *> void BinaryDeserializer::read(Type &customType) +template > *> BinaryVersion BinaryDeserializer::read(Type &customType) { - readCustomType(*this, customType); + return readCustomType(*this, customType); } inline BinarySerializer::BinarySerializer(std::ostream *stream) diff --git a/lib/binary/serializable.h b/lib/binary/serializable.h index d67f8ed..4ad4927 100644 --- a/lib/binary/serializable.h +++ b/lib/binary/serializable.h @@ -17,28 +17,30 @@ namespace ReflectiveRapidJSON { /*! * \brief The BinarySerializable class provides the CRTP-base for (de)serializable objects. */ -template struct BinarySerializable { - void toBinary(std::ostream &outputStream) const; - void restoreFromBinary(std::istream &inputStream); +template struct BinarySerializable { + void toBinary(std::ostream &outputStream, BinaryVersion version = 0) const; + BinaryVersion restoreFromBinary(std::istream &inputStream); static Type fromBinary(std::istream &inputStream); static constexpr const char *qualifiedName = "ReflectiveRapidJSON::BinarySerializable"; - static constexpr auto defaultSerializeVersion = defaultVersion; + static constexpr auto version = v; + static constexpr auto versioningEnabled(const BinarySerializable &) + { + return v != 0; + } }; -template -inline void BinarySerializable::toBinary(std::ostream &outputStream) const +template inline void BinarySerializable::toBinary(std::ostream &outputStream, BinaryVersion version) const { - BinaryReflector::BinarySerializer(&outputStream).write(static_cast(*this), defaultVersion); + BinaryReflector::BinarySerializer(&outputStream).write(static_cast(*this), version); } -template -inline void BinarySerializable::restoreFromBinary(std::istream &inputStream) +template inline BinaryVersion BinarySerializable::restoreFromBinary(std::istream &inputStream) { - BinaryReflector::BinaryDeserializer(&inputStream).read(static_cast(*this)); + return BinaryReflector::BinaryDeserializer(&inputStream).read(static_cast(*this)); } -template Type BinarySerializable::fromBinary(std::istream &inputStream) +template Type BinarySerializable::fromBinary(std::istream &inputStream) { Type object; static_cast &>(object).restoreFromBinary(inputStream); diff --git a/lib/tests/binaryreflector.cpp b/lib/tests/binaryreflector.cpp index d9421ed..b9f45c7 100644 --- a/lib/tests/binaryreflector.cpp +++ b/lib/tests/binaryreflector.cpp @@ -75,7 +75,7 @@ struct ObjectWithVariantsBinary : public BinarySerializable void readCustomType(BinaryDeserializer &deserializer, TestObjectBinary &customType) +template <> BinaryVersion readCustomType(BinaryDeserializer &deserializer, TestObjectBinary &customType) { deserializer.read(customType.number); deserializer.read(customType.number2); @@ -92,10 +92,12 @@ template <> void readCustomType(BinaryDeserializer &deserializ deserializer.read(customType.someEnumClass); deserializer.read(customType.timeSpan); deserializer.read(customType.dateTime); + return 0; } template <> void writeCustomType(BinarySerializer &serializer, const TestObjectBinary &customType, BinaryVersion version) { + CPP_UTILITIES_UNUSED(version) serializer.write(customType.number); serializer.write(customType.number2); serializer.write(customType.numbers); @@ -113,10 +115,11 @@ template <> void writeCustomType(BinarySerializer &serializer, serializer.write(customType.dateTime); } -template <> void readCustomType(BinaryDeserializer &deserializer, NestingArrayBinary &customType) +template <> BinaryVersion readCustomType(BinaryDeserializer &deserializer, NestingArrayBinary &customType) { deserializer.read(customType.name); deserializer.read(customType.testObjects); + return 0; } template <> void writeCustomType(BinarySerializer &serializer, const NestingArrayBinary &customType, BinaryVersion version) @@ -125,16 +128,18 @@ template <> void writeCustomType(BinarySerializer &serialize serializer.write(customType.testObjects); } -template <> void readCustomType(BinaryDeserializer &deserializer, ObjectWithVariantsBinary &customType) +template <> BinaryVersion readCustomType(BinaryDeserializer &deserializer, ObjectWithVariantsBinary &customType) { deserializer.read(customType.someVariant); deserializer.read(customType.anotherVariant); deserializer.read(customType.yetAnotherVariant); + return 0; } template <> void writeCustomType(BinarySerializer &serializer, const ObjectWithVariantsBinary &customType, BinaryVersion version) { + CPP_UTILITIES_UNUSED(version) serializer.write(customType.someVariant); serializer.write(customType.anotherVariant); serializer.write(customType.yetAnotherVariant); diff --git a/lib/tests/traits.cpp b/lib/tests/traits.cpp index f996cc8..6689957 100644 --- a/lib/tests/traits.cpp +++ b/lib/tests/traits.cpp @@ -1,13 +1,27 @@ #include "../traits.h" +#include "../versioning.h" + +#include "../binary/serializable.h" #include #include -// treat some types differently to test Treat... traits +// define structs for testing REFLECTIVE_RAPIDJSON_TREAT_AS_… struct Foo { }; struct Bar { }; + +// define structs for testing versioning +struct VersionlessBase : public ReflectiveRapidJSON::BinarySerializable { +}; +struct VersionedDerived : public VersionlessBase, public ReflectiveRapidJSON::BinarySerializable { +}; +struct VersionedBase : public ReflectiveRapidJSON::BinarySerializable { +}; +struct VersionlessDerived : public VersionedBase, public ReflectiveRapidJSON::BinarySerializable { +}; + namespace ReflectiveRapidJSON { REFLECTIVE_RAPIDJSON_TREAT_AS_MAP_OR_HASH(Foo); REFLECTIVE_RAPIDJSON_TREAT_AS_MULTI_MAP_OR_HASH(Foo); @@ -48,3 +62,14 @@ static_assert(IsIteratableExceptString>::value, "vector is iter static_assert(!IsIteratableExceptString::value, "string not iteratable"); static_assert(!IsIteratableExceptString::value, "wstring not iteratable"); static_assert(!IsIteratableExceptString::value, "string not iteratable"); + +// test versioning traits +static_assert(!Versioning::enabled, "versioning for built-in types not enabled"); +static_assert(!Versioning::enabled, "versioning for standard types not enabled"); +static_assert(!Versioning::enabled, "versioning not enabled by default"); +static_assert(Versioning>::enabled, "versioning enabled if non-zero version parameter specified (derived)"); +static_assert(Versioning::enabled, "versioning enabled if non-zero version parameter specified (base)"); +static_assert(!Versioning>::enabled, "versioning disabled for derived, even if base is versioned"); +static_assert(!Versioning>::enabled, "versioning disabled if zero-version specified"); +static_assert(Versioning>::applyDefault(0) == 3, "default version returned"); +static_assert(Versioning>::applyDefault(2) == 2, "default version overridden"); diff --git a/lib/versioning.h b/lib/versioning.h index 6e7cd96..ff4049f 100644 --- a/lib/versioning.h +++ b/lib/versioning.h @@ -1,6 +1,8 @@ #ifndef REFLECTIVE_RAPIDJSON_VERSIONING #define REFLECTIVE_RAPIDJSON_VERSIONING +#include + namespace ReflectiveRapidJSON { #ifdef REFLECTIVE_RAPIDJSON_GENERATOR @@ -22,6 +24,27 @@ public #define until_version(version) REFLECTIVE_RAPIDJSON_UNTIL_VERSION(version) #endif +CPP_UTILITIES_TRAITS_DEFINE_TYPE_CHECK(IsVersioned, T::version); +//CPP_UTILITIES_TRAITS_DEFINE_TYPE_CHECK(IsVersioned, T::versioningEnabled(std::declval())); + +//using BinaryVersion = std::uint64_t; + +//template struct BinarySerializable; +//CPP_UTILITIES_TRAITS_DEFINE_TYPE_CHECK(IsVersioned, static_cast(std::declval()).version); + +template ::value> struct Versioning { + static constexpr auto enabled = false; +}; + +template struct Versioning { + static constexpr auto enabled = Type::version != 0; + static constexpr auto serializationDefault = Type::version; + static constexpr auto applyDefault(decltype(serializationDefault) version) + { + return version ? version : serializationDefault; + } +}; + } // namespace ReflectiveRapidJSON #endif // REFLECTIVE_RAPIDJSON_TRAITS