diff options
59 files changed, 2248 insertions, 2163 deletions
diff --git a/Jamroot.jam b/Jamroot.jam index 98e8e4c..9d1aa16 100644 --- a/Jamroot.jam +++ b/Jamroot.jam @@ -23,26 +23,33 @@ project <variant>coverage:<coverage>on <toolset>tidy:<checkxx>boost-* <toolset>tidy:<checkxx>bugprone-* + <toolset>tidy:<xcheckxx>bugprone-macro-parentheses <toolset>tidy:<checkxx>clang-* + <toolset>tidy:<xcheckxx>clang-analyzer-cplusplus.NewDeleteLeaks <toolset>tidy:<checkxx>misc-* + <toolset>tidy:<xcheckxx>misc-non-private-member-variables-in-classes <toolset>tidy:<checkxx>modernize-* <toolset>tidy:<xcheckxx>modernize-use-trailing-return-type <toolset>tidy:<checkxx>hicpp-* + <toolset>tidy:<xcheckxx>hicpp-no-array-decay + <toolset>tidy:<xcheckxx>hicpp-vararg <toolset>tidy:<checkxx>performance-* - <toolset>tidy:<exclude>test/bin/tidy/debug/classes.h - <toolset>tidy:<exclude>test/bin/tidy/debug/classtype.h - <toolset>tidy:<exclude>test/bin/tidy/debug/collections.h - <toolset>tidy:<exclude>test/bin/tidy/debug/enums.h - <toolset>tidy:<exclude>test/bin/tidy/debug/inheritance.h - <toolset>tidy:<exclude>test/bin/tidy/debug/interfaces.h - <toolset>tidy:<exclude>test/bin/tidy/debug/json.h - <toolset>tidy:<exclude>test/bin/tidy/debug/locals.h - <toolset>tidy:<exclude>test/bin/tidy/debug/optionals.h - <toolset>tidy:<exclude>test/bin/tidy/debug/structs.h - <toolset>tidy:<exclude>test/bin/tidy/debug/types.h - <toolset>tidy:<exclude>test/bin/tidy/debug/xml.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/classes.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/classtype.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/collections.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/enums.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/inheritance.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/interfaces.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/json.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/locals.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/optionals.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/structs.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/types.h + <toolset>tidy:<exclude>test/bin/tidy/debug/cxxstd-17-iso/xml.h <toolset>tidy:<exclude>slicer/bin/common.h <toolset>tidy:<exclude>xml/bin/tidy/debug/cxxstd-17-iso/xmlExceptions.h + <toolset>tidy:<exclude>db/bin/tidy/debug/cxxstd-17-iso/sqlExceptions.h + <toolset>tidy:<exclude>db/bin/tidy/debug/cxxstd-17-iso/testModels.h ; build-project slicer ; diff --git a/slicer/Jamfile.jam b/slicer/Jamfile.jam index d6f47ff..387a313 100644 --- a/slicer/Jamfile.jam +++ b/slicer/Jamfile.jam @@ -8,8 +8,7 @@ build-project db ; build-project ice ; build-project test ; -lib boost_utf : : <name>boost_unit_test_framework : : - <toolset>tidy:<xcheckxx>hicpp-* ; +lib boost_utf : : <name>boost_unit_test_framework ; lib adhocutil : : : : <include>/usr/include/adhocutil ; lib Ice++11 ; lib pthread ; diff --git a/slicer/db/Jamfile.jam b/slicer/db/Jamfile.jam index fcfa4d3..7a5de7e 100644 --- a/slicer/db/Jamfile.jam +++ b/slicer/db/Jamfile.jam @@ -39,7 +39,6 @@ lib testCommon : : <dependency>../tool//slicer <slicer>pure - <slicerbin>../tool//slicer <implicit-dependency>../test//types <library>../test//types <library>../test//common @@ -48,6 +47,12 @@ lib testCommon : <library>..//adhocutil <library>dbicetypes <implicit-dependency>dbicetypes + <toolset>gcc:<dependency>../tool//slicer/<toolset>gcc + <toolset>clang:<dependency>../tool//slicer/<toolset>clang + <toolset>tidy:<dependency>../tool//slicer/<toolset>gcc + <toolset>gcc:<slicerbin>../tool//slicer/<toolset>gcc + <toolset>clang:<slicerbin>../tool//slicer/<toolset>clang + <toolset>tidy:<slicerbin>../tool//slicer/<toolset>gcc : : <library>..//adhocutil <library>dbicetypes diff --git a/slicer/db/sqlBinder.cpp b/slicer/db/sqlBinder.cpp index 6969749..8245217 100644 --- a/slicer/db/sqlBinder.cpp +++ b/slicer/db/sqlBinder.cpp @@ -1,11 +1,7 @@ #include "sqlBinder.h" namespace Slicer { - SqlBinder::SqlBinder(DB::Command & c, unsigned int i) : - command(c), - idx(i) - { - } + SqlBinder::SqlBinder(DB::Command & c, unsigned int i) : command(c), idx(i) { } void SqlBinder::get(const boost::posix_time::ptime & b) const @@ -67,4 +63,3 @@ namespace Slicer { command.bindParamS(idx, b); } } - diff --git a/slicer/db/sqlBinder.h b/slicer/db/sqlBinder.h index f7a0be6..8c1ce80 100644 --- a/slicer/db/sqlBinder.h +++ b/slicer/db/sqlBinder.h @@ -1,36 +1,34 @@ #ifndef SLICER_DB_SQLBINDER_H #define SLICER_DB_SQLBINDER_H -#include <slicer/modelParts.h> -#include <command.h> #include <boost/date_time/posix_time/ptime.hpp> +#include <command.h> +#include <slicer/modelParts.h> namespace Slicer { - class SqlBinder : public Slicer::ValueTarget, - public Slicer::TValueTarget<boost::posix_time::time_duration>, - public Slicer::TValueTarget<boost::posix_time::ptime> - { - public: - SqlBinder(DB::Command & c, unsigned int idx); + class SqlBinder : + public Slicer::ValueTarget, + public Slicer::TValueTarget<boost::posix_time::time_duration>, + public Slicer::TValueTarget<boost::posix_time::ptime> { + public: + SqlBinder(DB::Command & c, unsigned int idx); - void get(const boost::posix_time::ptime & b) const override; - void get(const boost::posix_time::time_duration & b) const override; - void get(const bool & b) const override; - void get(const Ice::Byte & b) const override; - void get(const Ice::Short & b) const override; - void get(const Ice::Int & b) const override; - void get(const Ice::Long & b) const override; - void get(const Ice::Float & b) const override; - void get(const Ice::Double & b) const override; - void get(const std::string & b) const override; + void get(const boost::posix_time::ptime & b) const override; + void get(const boost::posix_time::time_duration & b) const override; + void get(const bool & b) const override; + void get(const Ice::Byte & b) const override; + void get(const Ice::Short & b) const override; + void get(const Ice::Int & b) const override; + void get(const Ice::Long & b) const override; + void get(const Ice::Float & b) const override; + void get(const Ice::Double & b) const override; + void get(const std::string & b) const override; - private: - DB::Command & command; - const unsigned int idx; + private: + DB::Command & command; + const unsigned int idx; }; typedef std::shared_ptr<SqlBinder> SqlBinderPtr; } #endif - - diff --git a/slicer/db/sqlCommon.cpp b/slicer/db/sqlCommon.cpp index 193285e..ecce6cc 100644 --- a/slicer/db/sqlCommon.cpp +++ b/slicer/db/sqlCommon.cpp @@ -1,7 +1,7 @@ -#include <sqlExceptions.h> -#include <compileTimeFormatter.h> #include "sqlCommon.h" +#include <compileTimeFormatter.h> #include <metadata.h> +#include <sqlExceptions.h> namespace Slicer { const std::string md_pkey = "db:pkey"; @@ -9,53 +9,61 @@ namespace Slicer { const std::string md_ignore = "db:ignore"; const std::string md_global_ignore = "ignore"; - bool isPKey(const HookCommon * h) + bool + isPKey(const HookCommon * h) { return metaDataFlagSet(h->GetMetadata(), md_pkey) && isBind(h); } - bool isAuto(const HookCommon * h) + bool + isAuto(const HookCommon * h) { return metaDataFlagSet(h->GetMetadata(), md_auto) && isBind(h); } - bool isNotAuto(const HookCommon * h) + bool + isNotAuto(const HookCommon * h) { return metaDataFlagNotSet(h->GetMetadata(), md_auto) && isBind(h); } - bool isBind(const HookCommon * h) + bool + isBind(const HookCommon * h) { - return metaDataFlagNotSet(h->GetMetadata(), md_global_ignore) && - metaDataFlagNotSet(h->GetMetadata(), md_ignore); + return metaDataFlagNotSet(h->GetMetadata(), md_global_ignore) + && metaDataFlagNotSet(h->GetMetadata(), md_ignore); } - bool isValue(const HookCommon * h) + bool + isValue(const HookCommon * h) { - return metaDataFlagNotSet(h->GetMetadata(), md_auto) && - metaDataFlagNotSet(h->GetMetadata(), md_pkey) && isBind(h); + return metaDataFlagNotSet(h->GetMetadata(), md_auto) && metaDataFlagNotSet(h->GetMetadata(), md_pkey) + && isBind(h); } - void TooManyRowsReturned::ice_print(std::ostream & s) const + void + TooManyRowsReturned::ice_print(std::ostream & s) const { s << "Too many rows returned"; } - void NoRowsReturned::ice_print(std::ostream & s) const + void + NoRowsReturned::ice_print(std::ostream & s) const { s << "No rows returned"; } - void NoRowsFound::ice_print(std::ostream & s) const + void + NoRowsFound::ice_print(std::ostream & s) const { s << "No rows found"; } AdHocFormatter(UnsuitableIdFieldTypeMsg, "Unsuitable id field type [%?]"); - void UnsuitableIdFieldType::ice_print(std::ostream & s) const + void + UnsuitableIdFieldType::ice_print(std::ostream & s) const { UnsuitableIdFieldTypeMsg::write(s, type); } } - diff --git a/slicer/db/sqlCommon.h b/slicer/db/sqlCommon.h index 954800a..32afd87 100644 --- a/slicer/db/sqlCommon.h +++ b/slicer/db/sqlCommon.h @@ -1,8 +1,8 @@ #ifndef SLICER_DB_SQLCOMMON_H #define SLICER_DB_SQLCOMMON_H -#include <string> #include <modelParts.h> +#include <string> namespace Slicer { bool isPKey(const HookCommon *); @@ -13,4 +13,3 @@ namespace Slicer { } #endif - diff --git a/slicer/db/sqlInsertSerializer.cpp b/slicer/db/sqlInsertSerializer.cpp index dde8f1f..4061b17 100644 --- a/slicer/db/sqlInsertSerializer.cpp +++ b/slicer/db/sqlInsertSerializer.cpp @@ -1,20 +1,20 @@ -#include "sqlInsertSerializer.h" -#include <common.h> -#include <sqlExceptions.h> #include "sqlBinder.h" #include "sqlCommon.h" +#include "sqlInsertSerializer.h" +#include <boost/numeric/conversion/cast.hpp> +#include <common.h> #include <compileTimeFormatter.h> +#include <functional> #include <modifycommand.h> #include <slicer/metadata.h> -#include <boost/numeric/conversion/cast.hpp> -#include <functional> +#include <sqlExceptions.h> +#include <type_traits> namespace Slicer { using namespace std::placeholders; SqlInsertSerializer::SqlInsertSerializer(DB::Connection * const c, std::string t) : - connection(c), - tableName(std::move(t)) + connection(c), tableName(std::move(t)) { } @@ -22,11 +22,15 @@ namespace Slicer { SqlInsertSerializer::Serialize(Slicer::ModelPartForRootPtr mp) { switch (mp->GetType()) { - case Slicer::mpt_Sequence: - mp->OnEachChild(std::bind(&SqlInsertSerializer::SerializeSequence, this, _2)); + case Slicer::ModelPartType::Sequence: + mp->OnEachChild([this](auto &&, auto && PH2, auto &&) { + SerializeSequence(PH2); + }); return; - case Slicer::mpt_Complex: - mp->OnEachChild(std::bind(&SqlInsertSerializer::SerializeObject, this, _2)); + case Slicer::ModelPartType::Complex: + mp->OnEachChild([this](auto &&, auto && PH2, auto &&) { + SerializeObject(PH2); + }); return; default: throw UnsupportedModelType(); @@ -45,45 +49,52 @@ namespace Slicer { { auto ins = createInsert(mp->GetContainedModelPart()); mp->OnEachChild([&ins, this](const std::string &, const ModelPartPtr & cmp, const HookCommon *) { - bindObjectAndExecute(cmp, ins.get()); - }); + bindObjectAndExecute(cmp, ins.get()); + }); } void SqlInsertSerializer::bindObjectAndExecute(const Slicer::ModelPartPtr & cmp, DB::ModifyCommand * ins) const { int paramNo = 0; - cmp->OnEachChild(std::bind(&SqlInsertSerializer::bindObjectAndExecuteField, this, std::ref(paramNo), ins, _2, _3)); + cmp->OnEachChild([this, ¶mNo, ins](auto &&, auto && PH2, auto && PH3) { + bindObjectAndExecuteField(paramNo, ins, PH2, PH3); + }); ins->execute(); } class IdSave : public Slicer::ValueSource { - public: - explicit IdSave(DB::Connection * const c) : - connection(c) - { - } - -#define NonNumType(T) \ - /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ - void set(T &) const override { throw UnsuitableIdFieldType(#T); } + public: + explicit IdSave(DB::Connection * const c) : connection(c) { } #define NumType(T) \ - /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \ - void set(T & v) const override { v = boost::numeric_cast<T>(connection->insertId()); } - - NonNumType(bool); - NonNumType(std::string); - - NumType(Ice::Byte); - NumType(Ice::Short); - NumType(Ice::Int); - NumType(Ice::Long); - NumType(Ice::Float); - NumType(Ice::Double); + void set(T & v) const override \ + { \ + doSet(v, #T); \ + } - private: - DB::Connection * const connection; + NumType(bool); + NumType(std::string); + NumType(Ice::Byte); + NumType(Ice::Short); + NumType(Ice::Int); + NumType(Ice::Long); + NumType(Ice::Float); + NumType(Ice::Double); + + private: + DB::Connection * const connection; + template<typename T> + inline void + doSet([[maybe_unused]] T & v, [[maybe_unused]] const char * Tname) const + { + if constexpr (std::is_integral_v<T>) { + v = boost::numeric_cast<T>(connection->insertId()); + } + else { + throw UnsuitableIdFieldType(Tname); + } + } }; void @@ -98,7 +109,8 @@ namespace Slicer { } void - SqlInsertSerializer::bindObjectAndExecuteField(int & paramNo, DB::ModifyCommand * ins, const Slicer::ModelPartPtr & cmp, const HookCommon * h) const + SqlInsertSerializer::bindObjectAndExecuteField( + int & paramNo, DB::ModifyCommand * ins, const Slicer::ModelPartPtr & cmp, const HookCommon * h) const { if (isBind(h)) { if (!cmp->GetValue(SqlBinder(*ins, paramNo))) { @@ -109,7 +121,8 @@ namespace Slicer { } void - SqlAutoIdInsertSerializer::bindObjectAndExecuteField(int & paramNo, DB::ModifyCommand * ins, const Slicer::ModelPartPtr & cmp, const HookCommon * h) const + SqlAutoIdInsertSerializer::bindObjectAndExecuteField( + int & paramNo, DB::ModifyCommand * ins, const Slicer::ModelPartPtr & cmp, const HookCommon * h) const { if (isNotAuto(h)) { SqlInsertSerializer::bindObjectAndExecuteField(paramNo, ins, cmp, h); @@ -123,7 +136,9 @@ namespace Slicer { std::stringstream insert; "INSERT INTO %?("_fmt(insert, tableName); int fieldNo = 0; - mp->OnEachChild(std::bind(&SqlInsertSerializer::createInsertField, this, std::ref(fieldNo), std::ref(insert), _1, _3)); + mp->OnEachChild([this, &fieldNo, &insert](auto && PH1, auto &&, auto && PH3) { + createInsertField(fieldNo, insert, PH1, PH3); + }); insert << ") VALUES ("; for (; fieldNo > 1; --fieldNo) { insert << "?, "; @@ -133,7 +148,8 @@ namespace Slicer { } void - SqlInsertSerializer::createInsertField(int & fieldNo, std::ostream & insert, const std::string & name, const HookCommon * h) const + SqlInsertSerializer::createInsertField( + int & fieldNo, std::ostream & insert, const std::string & name, const HookCommon * h) const { if (isBind(h)) { if (fieldNo++) { @@ -144,7 +160,8 @@ namespace Slicer { } void - SqlAutoIdInsertSerializer::createInsertField(int & fieldNo, std::ostream & insert, const std::string & name, const HookCommon * h) const + SqlAutoIdInsertSerializer::createInsertField( + int & fieldNo, std::ostream & insert, const std::string & name, const HookCommon * h) const { if (isNotAuto(h)) { if (fieldNo++) { @@ -154,4 +171,3 @@ namespace Slicer { } } } - diff --git a/slicer/db/sqlInsertSerializer.h b/slicer/db/sqlInsertSerializer.h index 175706f..6150d66 100644 --- a/slicer/db/sqlInsertSerializer.h +++ b/slicer/db/sqlInsertSerializer.h @@ -1,49 +1,50 @@ #ifndef SLICER_DB_SQLINSERTSERIALIZER_H #define SLICER_DB_SQLINSERTSERIALIZER_H -#include <slicer/serializer.h> #include <connection.h> -#include <visibility.h> #include <ostream> +#include <slicer/serializer.h> +#include <visibility.h> namespace Slicer { class DLL_PUBLIC SqlInsertSerializer : public Slicer::Serializer { - public: - SqlInsertSerializer(DB::Connection * const, std::string tableName); - - void Serialize(Slicer::ModelPartForRootPtr) override; - - protected: - void SerializeObject(const Slicer::ModelPartPtr &) const; - void SerializeSequence(const Slicer::ModelPartPtr &) const; - DB::ModifyCommandPtr createInsert(const Slicer::ModelPartPtr &) const; - virtual void createInsertField(int & fieldNo, std::ostream & insert, const std::string & name, const HookCommon * h) const; - virtual void bindObjectAndExecute(const Slicer::ModelPartPtr &, DB::ModifyCommand *) const; - virtual void bindObjectAndExecuteField(int & paramNo, DB::ModifyCommand *, const Slicer::ModelPartPtr &, const HookCommon *) const; - - DB::Connection * const connection; - const std::string tableName; + public: + SqlInsertSerializer(DB::Connection * const, std::string tableName); + + void Serialize(Slicer::ModelPartForRootPtr) override; + + protected: + void SerializeObject(const Slicer::ModelPartPtr &) const; + void SerializeSequence(const Slicer::ModelPartPtr &) const; + DB::ModifyCommandPtr createInsert(const Slicer::ModelPartPtr &) const; + virtual void createInsertField( + int & fieldNo, std::ostream & insert, const std::string & name, const HookCommon * h) const; + virtual void bindObjectAndExecute(const Slicer::ModelPartPtr &, DB::ModifyCommand *) const; + virtual void bindObjectAndExecuteField( + int & paramNo, DB::ModifyCommand *, const Slicer::ModelPartPtr &, const HookCommon *) const; + + DB::Connection * const connection; + const std::string tableName; }; class DLL_PUBLIC SqlAutoIdInsertSerializer : public SqlInsertSerializer { - public: - template <typename ... P> - SqlAutoIdInsertSerializer(const P & ... p) : SqlInsertSerializer(p...) { } - - protected: - virtual void createInsertField(int & fieldNo, std::ostream & insert, const std::string & name, const HookCommon * h) const; - virtual void bindObjectAndExecuteField(int & paramNo, DB::ModifyCommand *, const Slicer::ModelPartPtr &, const HookCommon *) const; + public: + template<typename... P> SqlAutoIdInsertSerializer(const P &... p) : SqlInsertSerializer(p...) { } + + protected: + virtual void createInsertField( + int & fieldNo, std::ostream & insert, const std::string & name, const HookCommon * h) const; + virtual void bindObjectAndExecuteField( + int & paramNo, DB::ModifyCommand *, const Slicer::ModelPartPtr &, const HookCommon *) const; }; class DLL_PUBLIC SqlFetchIdInsertSerializer : public SqlAutoIdInsertSerializer { - public: - template <typename ... P> - SqlFetchIdInsertSerializer(const P & ... p) : SqlAutoIdInsertSerializer(p...) { } + public: + template<typename... P> SqlFetchIdInsertSerializer(const P &... p) : SqlAutoIdInsertSerializer(p...) { } - protected: - virtual void bindObjectAndExecute(const Slicer::ModelPartPtr &, DB::ModifyCommand *) const; + protected: + virtual void bindObjectAndExecute(const Slicer::ModelPartPtr &, DB::ModifyCommand *) const; }; } #endif - diff --git a/slicer/db/sqlSelectDeserializer.cpp b/slicer/db/sqlSelectDeserializer.cpp index ff16c43..8982958 100644 --- a/slicer/db/sqlSelectDeserializer.cpp +++ b/slicer/db/sqlSelectDeserializer.cpp @@ -1,13 +1,11 @@ #include "sqlSelectDeserializer.h" #include "sqlSource.h" -#include <sqlExceptions.h> #include <common.h> +#include <sqlExceptions.h> namespace Slicer { SqlSelectDeserializer::SqlSelectDeserializer(DB::SelectCommand * c, Ice::optional<std::string> tc) : - cmd(c), - columnCount(0), - typeIdColName(std::move(tc)) + cmd(c), columnCount(0), typeIdColName(std::move(tc)) { } @@ -20,13 +18,13 @@ namespace Slicer { typeIdColIdx = cmd->getOrdinal(*typeIdColName); } switch (mp->GetType()) { - case Slicer::mpt_Sequence: + case Slicer::ModelPartType::Sequence: DeserializeSequence(mp); return; - case Slicer::mpt_Complex: + case Slicer::ModelPartType::Complex: DeserializeObject(mp); return; - case Slicer::mpt_Simple: + case Slicer::ModelPartType::Simple: DeserializeSimple(mp); return; default: @@ -74,7 +72,7 @@ namespace Slicer { } DeserializeRow(mp); if (cmd->fetch()) { - while (cmd->fetch()) {} + while (cmd->fetch()) { } throw TooManyRowsReturned(); } } @@ -85,43 +83,38 @@ namespace Slicer { auto rmp = mp->GetAnonChild(); if (rmp) { switch (rmp->GetType()) { - case Slicer::mpt_Complex: - { - if (typeIdColIdx) { - std::string subclass; - (*cmd)[*typeIdColIdx] >> subclass; - rmp = rmp->GetSubclassModelPart(subclass); - } - rmp->Create(); - for (auto col = 0U; col < columnCount; col += 1) { - const DB::Column & c = (*cmd)[col]; - if (!c.isNull()) { - auto fmpr = rmp->GetChildRef(c.name, nullptr, false); - if (fmpr) { - auto fmp = fmpr.Child(); - fmp->Create(); - fmp->SetValue(SqlSource(c)); - fmp->Complete(); - } - } - } - rmp->Complete(); + case Slicer::ModelPartType::Complex: { + if (typeIdColIdx) { + std::string subclass; + (*cmd)[*typeIdColIdx] >> subclass; + rmp = rmp->GetSubclassModelPart(subclass); } - break; - case Slicer::mpt_Simple: - { - rmp->Create(); - const DB::Column & c = (*cmd)[0]; + rmp->Create(); + for (auto col = 0U; col < columnCount; col += 1) { + const DB::Column & c = (*cmd)[col]; if (!c.isNull()) { - rmp->SetValue(SqlSource(c)); + auto fmpr = rmp->GetChildRef(c.name, nullptr, false); + if (fmpr) { + auto fmp = fmpr.Child(); + fmp->Create(); + fmp->SetValue(SqlSource(c)); + fmp->Complete(); + } } - rmp->Complete(); } - break; + rmp->Complete(); + } break; + case Slicer::ModelPartType::Simple: { + rmp->Create(); + const DB::Column & c = (*cmd)[0]; + if (!c.isNull()) { + rmp->SetValue(SqlSource(c)); + } + rmp->Complete(); + } break; default: throw UnsupportedModelType(); } } } } - diff --git a/slicer/db/sqlSelectDeserializer.h b/slicer/db/sqlSelectDeserializer.h index e9afd1d..5f34ef4 100644 --- a/slicer/db/sqlSelectDeserializer.h +++ b/slicer/db/sqlSelectDeserializer.h @@ -1,29 +1,28 @@ #ifndef SLICER_DB_SQLSELECTDESERIALIZER_H #define SLICER_DB_SQLSELECTDESERIALIZER_H -#include <slicer/serializer.h> #include <selectcommand.h> +#include <slicer/serializer.h> #include <visibility.h> namespace Slicer { class DLL_PUBLIC SqlSelectDeserializer : public Slicer::Deserializer { - public: - SqlSelectDeserializer(DB::SelectCommand *, Ice::optional<std::string> typeIdCol = Ice::optional<std::string>()); + public: + SqlSelectDeserializer(DB::SelectCommand *, Ice::optional<std::string> typeIdCol = Ice::optional<std::string>()); - void Deserialize(Slicer::ModelPartForRootPtr) override; + void Deserialize(Slicer::ModelPartForRootPtr) override; - protected: - void DLL_PRIVATE DeserializeSimple(const Slicer::ModelPartPtr &); - void DLL_PRIVATE DeserializeObject(const Slicer::ModelPartPtr &); - void DLL_PRIVATE DeserializeSequence(const Slicer::ModelPartPtr &); - void DLL_PRIVATE DeserializeRow(const Slicer::ModelPartPtr &); + protected: + void DLL_PRIVATE DeserializeSimple(const Slicer::ModelPartPtr &); + void DLL_PRIVATE DeserializeObject(const Slicer::ModelPartPtr &); + void DLL_PRIVATE DeserializeSequence(const Slicer::ModelPartPtr &); + void DLL_PRIVATE DeserializeRow(const Slicer::ModelPartPtr &); - DB::SelectCommand * cmd; - unsigned int columnCount; - Ice::optional<std::string> typeIdColName; - Ice::optional<unsigned int> typeIdColIdx; + DB::SelectCommand * cmd; + unsigned int columnCount; + Ice::optional<std::string> typeIdColName; + Ice::optional<unsigned int> typeIdColIdx; }; } #endif - diff --git a/slicer/db/sqlSource.cpp b/slicer/db/sqlSource.cpp index eeea99c..84964f2 100644 --- a/slicer/db/sqlSource.cpp +++ b/slicer/db/sqlSource.cpp @@ -2,10 +2,7 @@ #include <boost/numeric/conversion/cast.hpp> namespace Slicer { - SqlSource::SqlSource(const DB::Column & c) : - column(c) - { - } + SqlSource::SqlSource(const DB::Column & c) : column(c) { } bool SqlSource::isNull() const @@ -83,4 +80,3 @@ namespace Slicer { column >> b; } } - diff --git a/slicer/db/sqlSource.h b/slicer/db/sqlSource.h index 99ffabb..548f35e 100644 --- a/slicer/db/sqlSource.h +++ b/slicer/db/sqlSource.h @@ -1,35 +1,34 @@ #ifndef SLICER_DB_SQLSOURCE_H #define SLICER_DB_SQLSOURCE_H -#include <slicer/modelParts.h> -#include <column.h> #include <boost/date_time/posix_time/ptime.hpp> +#include <column.h> +#include <slicer/modelParts.h> namespace Slicer { - class SqlSource : public Slicer::ValueSource, - public Slicer::TValueSource<boost::posix_time::time_duration>, - public Slicer::TValueSource<boost::posix_time::ptime> - { - public: - SqlSource(const DB::Column & c); + class SqlSource : + public Slicer::ValueSource, + public Slicer::TValueSource<boost::posix_time::time_duration>, + public Slicer::TValueSource<boost::posix_time::ptime> { + public: + SqlSource(const DB::Column & c); - bool isNull() const; - void set(boost::posix_time::ptime & b) const override; - void set(boost::posix_time::time_duration & b) const override; - void set(bool & b) const override; - void set(Ice::Byte & b) const override; - void set(Ice::Short & b) const override; - void set(Ice::Int & b) const override; - void set(Ice::Long & b) const override; - void set(Ice::Float & b) const override; - void set(Ice::Double & b) const override; - void set(std::string & b) const override; + bool isNull() const; + void set(boost::posix_time::ptime & b) const override; + void set(boost::posix_time::time_duration & b) const override; + void set(bool & b) const override; + void set(Ice::Byte & b) const override; + void set(Ice::Short & b) const override; + void set(Ice::Int & b) const override; + void set(Ice::Long & b) const override; + void set(Ice::Float & b) const override; + void set(Ice::Double & b) const override; + void set(std::string & b) const override; - private: - const DB::Column & column; + private: + const DB::Column & column; }; typedef std::shared_ptr<SqlSource> SqlSourcePtr; } #endif - diff --git a/slicer/db/sqlTablePatchSerializer.cpp b/slicer/db/sqlTablePatchSerializer.cpp index ec5b59b..7c29be5 100644 --- a/slicer/db/sqlTablePatchSerializer.cpp +++ b/slicer/db/sqlTablePatchSerializer.cpp @@ -1,16 +1,15 @@ -#include "sqlTablePatchSerializer.h" -#include "sqlInsertSerializer.h" #include "sqlCommon.h" -#include <slicer/metadata.h> +#include "sqlInsertSerializer.h" +#include "sqlTablePatchSerializer.h" #include <compileTimeFormatter.h> -#include <scopeExit.h> #include <functional> +#include <scopeExit.h> +#include <slicer/metadata.h> namespace Slicer { AdHocFormatter(ttname, "slicer_tmp_%?"); SqlTablePatchSerializer::SqlTablePatchSerializer(DB::Connection * const db, DB::TablePatch & tp) : - db(db), - tablePatch(tp) + db(db), tablePatch(tp) { tablePatch.src = ttname::get(this); } @@ -22,7 +21,9 @@ namespace Slicer { tablePatch.cols.clear(); createTemporaryTable(); - AdHoc::ScopeExit tidy(std::bind(&SqlTablePatchSerializer::dropTemporaryTable, this)); + AdHoc::ScopeExit tidy([this] { + dropTemporaryTable(); + }); SqlInsertSerializer ins(db, tablePatch.src); ins.Serialize(mpr); @@ -56,4 +57,3 @@ namespace Slicer { db->execute(dropTmpTable::get(tablePatch.src)); } } - diff --git a/slicer/db/sqlTablePatchSerializer.h b/slicer/db/sqlTablePatchSerializer.h index 00ea328..9a82f85 100644 --- a/slicer/db/sqlTablePatchSerializer.h +++ b/slicer/db/sqlTablePatchSerializer.h @@ -6,19 +6,18 @@ namespace Slicer { class DLL_PUBLIC SqlTablePatchSerializer : public Slicer::Serializer { - public: - SqlTablePatchSerializer(DB::Connection * const, DB::TablePatch &); + public: + SqlTablePatchSerializer(DB::Connection * const, DB::TablePatch &); - void Serialize(Slicer::ModelPartForRootPtr) override; + void Serialize(Slicer::ModelPartForRootPtr) override; - private: - void createTemporaryTable(); - void dropTemporaryTable(); + private: + void createTemporaryTable(); + void dropTemporaryTable(); - DB::Connection * const db; - DB::TablePatch & tablePatch; + DB::Connection * const db; + DB::TablePatch & tablePatch; }; } #endif - diff --git a/slicer/db/sqlUpdateSerializer.cpp b/slicer/db/sqlUpdateSerializer.cpp index 64ff1a0..29d9da7 100644 --- a/slicer/db/sqlUpdateSerializer.cpp +++ b/slicer/db/sqlUpdateSerializer.cpp @@ -1,19 +1,18 @@ -#include "sqlUpdateSerializer.h" -#include <sqlExceptions.h> -#include <common.h> #include "sqlBinder.h" #include "sqlCommon.h" +#include "sqlUpdateSerializer.h" +#include <common.h> #include <compileTimeFormatter.h> +#include <functional> #include <modifycommand.h> #include <slicer/metadata.h> -#include <functional> +#include <sqlExceptions.h> namespace Slicer { using namespace std::placeholders; SqlUpdateSerializer::SqlUpdateSerializer(DB::Connection * const c, std::string t) : - connection(c), - tableName(std::move(t)) + connection(c), tableName(std::move(t)) { } @@ -21,11 +20,15 @@ namespace Slicer { SqlUpdateSerializer::Serialize(Slicer::ModelPartForRootPtr mp) { switch (mp->GetType()) { - case Slicer::mpt_Sequence: - mp->OnEachChild(std::bind(&SqlUpdateSerializer::SerializeSequence, this, _2)); + case Slicer::ModelPartType::Sequence: + mp->OnEachChild([this](auto &&, auto && PH2, auto &&) { + SerializeSequence(PH2); + }); return; - case Slicer::mpt_Complex: - mp->OnEachChild(std::bind(&SqlUpdateSerializer::SerializeObject, this, _2)); + case Slicer::ModelPartType::Complex: + mp->OnEachChild([this](auto &&, auto && PH2, auto &&) { + SerializeObject(PH2); + }); return; default: throw UnsupportedModelType(); @@ -44,8 +47,8 @@ namespace Slicer { { auto ins = createUpdate(mp->GetContainedModelPart()); mp->OnEachChild([&ins](const std::string &, const ModelPartPtr & cmp, const HookCommon *) { - bindObjectAndExecute(cmp, ins.get()); - }); + bindObjectAndExecute(cmp, ins.get()); + }); } void @@ -77,7 +80,7 @@ namespace Slicer { std::stringstream update; "UPDATE %? SET "_fmt(update, tableName); int fieldNo = 0; - mp->OnEachChild([&update, &fieldNo]( const std::string & name, const ModelPartPtr &, const HookCommon * h) { + mp->OnEachChild([&update, &fieldNo](const std::string & name, const ModelPartPtr &, const HookCommon * h) { if (isValue(h)) { if (fieldNo++) { update << ", "; @@ -87,7 +90,7 @@ namespace Slicer { }); update << " WHERE "; fieldNo = 0; - mp->OnEachChild([&update, &fieldNo]( const std::string & name, const ModelPartPtr &, const HookCommon * h) { + mp->OnEachChild([&update, &fieldNo](const std::string & name, const ModelPartPtr &, const HookCommon * h) { if (isPKey(h)) { if (fieldNo++) { update << " AND "; @@ -98,4 +101,3 @@ namespace Slicer { return connection->modify(update.str()); } } - diff --git a/slicer/db/sqlUpdateSerializer.h b/slicer/db/sqlUpdateSerializer.h index a3462f8..e82015b 100644 --- a/slicer/db/sqlUpdateSerializer.h +++ b/slicer/db/sqlUpdateSerializer.h @@ -1,27 +1,26 @@ #ifndef SLICER_DB_SQLUPDATESERIALIZER_H #define SLICER_DB_SQLUPDATESERIALIZER_H -#include <slicer/serializer.h> #include <connection.h> +#include <slicer/serializer.h> #include <visibility.h> namespace Slicer { class DLL_PUBLIC SqlUpdateSerializer : public Slicer::Serializer { - public: - SqlUpdateSerializer(DB::Connection * const, std::string tableName); + public: + SqlUpdateSerializer(DB::Connection * const, std::string tableName); - void Serialize(Slicer::ModelPartForRootPtr) override; + void Serialize(Slicer::ModelPartForRootPtr) override; - protected: - void SerializeObject(const Slicer::ModelPartPtr &) const; - void SerializeSequence(const Slicer::ModelPartPtr &) const; - DB::ModifyCommandPtr createUpdate(const Slicer::ModelPartPtr &) const; - static void bindObjectAndExecute(const Slicer::ModelPartPtr &, DB::ModifyCommand *); + protected: + void SerializeObject(const Slicer::ModelPartPtr &) const; + void SerializeSequence(const Slicer::ModelPartPtr &) const; + DB::ModifyCommandPtr createUpdate(const Slicer::ModelPartPtr &) const; + static void bindObjectAndExecute(const Slicer::ModelPartPtr &, DB::ModifyCommand *); - DB::Connection * const connection; - const std::string tableName; + DB::Connection * const connection; + const std::string tableName; }; } #endif - diff --git a/slicer/db/testConversions.cpp b/slicer/db/testConversions.cpp index d19f309..68de17a 100644 --- a/slicer/db/testConversions.cpp +++ b/slicer/db/testConversions.cpp @@ -1,16 +1,17 @@ -#include <testModels.h> #include <boost/date_time/posix_time/posix_time_types.hpp> #include <boost/numeric/conversion/cast.hpp> +#include <testModels.h> #include <visibility.h> -#define SHORT(x) boost::numeric_cast< ::Ice::Short , int64_t >(x) +#define SHORT(x) boost::numeric_cast<::Ice::Short, int64_t>(x) namespace Slicer { DLL_PUBLIC ::TestDatabase::TimespanPtr timedurationToTimespan(const boost::posix_time::time_duration & td) { - return std::make_shared<::TestDatabase::Timespan>(SHORT(td.hours() / 24), SHORT(td.hours() % 24), SHORT(td.minutes()), SHORT(td.seconds())); + return std::make_shared<::TestDatabase::Timespan>( + SHORT(td.hours() / 24), SHORT(td.hours() % 24), SHORT(td.minutes()), SHORT(td.seconds())); } DLL_PUBLIC @@ -20,4 +21,3 @@ namespace Slicer { return boost::posix_time::time_duration((ts->days * 24) + ts->hours, ts->minutes, ts->seconds); } } - diff --git a/slicer/db/testInsert.cpp b/slicer/db/testInsert.cpp index 3724679..6bc6acd 100644 --- a/slicer/db/testInsert.cpp +++ b/slicer/db/testInsert.cpp @@ -1,13 +1,13 @@ #define BOOST_TEST_MODULE db_insert -#include <boost/test/unit_test.hpp> -#include <boost/date_time/posix_time/posix_time_io.hpp> -#include "testMockCommon.h" -#include <slicer/slicer.h> #include "sqlInsertSerializer.h" #include "sqlSelectDeserializer.h" -#include <types.h> +#include "testMockCommon.h" +#include <boost/date_time/posix_time/posix_time_io.hpp> +#include <boost/test/unit_test.hpp> #include <common.h> +#include <slicer/slicer.h> #include <testModels.h> +#include <types.h> using namespace std::literals; @@ -19,16 +19,18 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(TestDatabase::Timespan); namespace std { template<typename T> - ostream & operator<<(ostream & s, const Ice::optional<T> &) { + ostream & + operator<<(ostream & s, const Ice::optional<T> &) + { return s; } } -BOOST_GLOBAL_FIXTURE( StandardMockDatabase ); +BOOST_GLOBAL_FIXTURE(StandardMockDatabase); BOOST_FIXTURE_TEST_SUITE(db, ConnectionFixture); -BOOST_AUTO_TEST_CASE( insert_builtins ) +BOOST_AUTO_TEST_CASE(insert_builtins) { TestModule::BuiltInsPtr bi = std::make_shared<TestModule::BuiltIns>(true, 4, 16, 64, 128, 1.2, 3.4, "text"); Slicer::SerializeAny<Slicer::SqlInsertSerializer>(bi, db, "builtins"); @@ -44,12 +46,10 @@ BOOST_AUTO_TEST_CASE( insert_builtins ) BOOST_REQUIRE_EQUAL(bi->mstring, bi2->mstring); } -BOOST_AUTO_TEST_CASE( insert_seq_builtins ) +BOOST_AUTO_TEST_CASE(insert_seq_builtins) { - TestModule::BuiltInSeq bis = { - std::make_shared<TestModule::BuiltIns>(true, 5, 17, 65, 129, 2.3, 4.5, "more text"), - std::make_shared<TestModule::BuiltIns>(true, 6, 18, 66, 130, 3.4, 5.6, "even more text") - }; + TestModule::BuiltInSeq bis = {std::make_shared<TestModule::BuiltIns>(true, 5, 17, 65, 129, 2.3, 4.5, "more text"), + std::make_shared<TestModule::BuiltIns>(true, 6, 18, 66, 130, 3.4, 5.6, "even more text")}; Slicer::SerializeAny<Slicer::SqlInsertSerializer>(bis, db, "builtins"); auto sel = db->select("SELECT * FROM builtins ORDER BY mint"); auto bis2 = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestModule::BuiltInSeq>(sel.get()); @@ -64,12 +64,10 @@ BOOST_AUTO_TEST_CASE( insert_seq_builtins ) BOOST_REQUIRE_EQUAL(bis.back()->mstring, bis2.back()->mstring); } -BOOST_AUTO_TEST_CASE( autoinsert_seq_builtins ) +BOOST_AUTO_TEST_CASE(autoinsert_seq_builtins) { - TestModule::BuiltInSeq bis = { - std::make_shared<TestModule::BuiltIns>(true, 5, 17, 0, 129, 2.3, 4.5, "more text"), - std::make_shared<TestModule::BuiltIns>(true, 6, 18, 0, 130, 3.4, 5.6, "even more text") - }; + TestModule::BuiltInSeq bis = {std::make_shared<TestModule::BuiltIns>(true, 5, 17, 0, 129, 2.3, 4.5, "more text"), + std::make_shared<TestModule::BuiltIns>(true, 6, 18, 0, 130, 3.4, 5.6, "even more text")}; Slicer::SerializeAny<Slicer::SqlAutoIdInsertSerializer>(bis, db, "builtins"); auto sel = db->select("SELECT * FROM builtins WHERE mint IN (1, 2) ORDER BY mint"); auto bis2 = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestModule::BuiltInSeq>(sel.get()); @@ -87,12 +85,10 @@ BOOST_AUTO_TEST_CASE( autoinsert_seq_builtins ) BOOST_REQUIRE_EQUAL(bis.back()->mstring, bis2.back()->mstring); } -BOOST_AUTO_TEST_CASE( fetchinsert_seq_builtins ) +BOOST_AUTO_TEST_CASE(fetchinsert_seq_builtins) { - TestModule::BuiltInSeq bis = { - std::make_shared<TestModule::BuiltIns>(true, 5, 17, 0, 129, 2.3, 4.5, "more text"), - std::make_shared<TestModule::BuiltIns>(true, 6, 18, 0, 130, 3.4, 5.6, "even more text") - }; + TestModule::BuiltInSeq bis = {std::make_shared<TestModule::BuiltIns>(true, 5, 17, 0, 129, 2.3, 4.5, "more text"), + std::make_shared<TestModule::BuiltIns>(true, 6, 18, 0, 130, 3.4, 5.6, "even more text")}; Slicer::SerializeAny<Slicer::SqlFetchIdInsertSerializer>(bis, db, "builtins"); auto sel = db->select("SELECT * FROM builtins WHERE mint IN (3, 4) ORDER BY mint"); auto bis2 = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestModule::BuiltInSeq>(sel.get()); @@ -110,12 +106,11 @@ BOOST_AUTO_TEST_CASE( fetchinsert_seq_builtins ) BOOST_REQUIRE_EQUAL(bis.back()->mstring, bis2.back()->mstring); } -BOOST_AUTO_TEST_CASE( fetchinsert_seq_builtinsWithNulls ) +BOOST_AUTO_TEST_CASE(fetchinsert_seq_builtinsWithNulls) { TestDatabase::BuiltInSeq bis = { - std::make_shared<TestDatabase::BuiltIns>(true, IceUtil::None, 17, 0, 129, 2.3, 4.5, "more text"s), - std::make_shared<TestDatabase::BuiltIns>(true, 6, 18, 0, 130, 3.4, IceUtil::None, "even more text"s) - }; + std::make_shared<TestDatabase::BuiltIns>(true, IceUtil::None, 17, 0, 129, 2.3, 4.5, "more text"s), + std::make_shared<TestDatabase::BuiltIns>(true, 6, 18, 0, 130, 3.4, IceUtil::None, "even more text"s)}; Slicer::SerializeAny<Slicer::SqlFetchIdInsertSerializer>(bis, db, "builtins"); auto sel = db->select("SELECT * FROM builtins WHERE mint IN (5, 6) ORDER BY mint"); auto bis2 = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestDatabase::BuiltInSeq>(sel.get()); @@ -133,13 +128,11 @@ BOOST_AUTO_TEST_CASE( fetchinsert_seq_builtinsWithNulls ) BOOST_REQUIRE_EQUAL(bis.back()->mstring, bis2.back()->mstring); } -BOOST_AUTO_TEST_CASE( insert_converted ) +BOOST_AUTO_TEST_CASE(insert_converted) { - TestDatabase::SpecificTypesPtr st = std::make_shared<TestDatabase::SpecificTypes>( - TestModule::DateTime {2015, 10, 16, 19, 12, 34}, - TestModule::IsoDate {2015, 10, 16}, - std::make_shared<TestDatabase::Timespan>(1, 2, 3, 4) - ); + TestDatabase::SpecificTypesPtr st + = std::make_shared<TestDatabase::SpecificTypes>(TestModule::DateTime {2015, 10, 16, 19, 12, 34}, + TestModule::IsoDate {2015, 10, 16}, std::make_shared<TestDatabase::Timespan>(1, 2, 3, 4)); Slicer::SerializeAny<Slicer::SqlInsertSerializer>(st, db, "converted"); auto sel = db->select("SELECT * FROM converted"); auto st2 = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestDatabase::SpecificTypesPtr>(sel.get()); @@ -151,11 +144,11 @@ BOOST_AUTO_TEST_CASE( insert_converted ) BOOST_REQUIRE_EQUAL(st->ts->seconds, st2->ts->seconds); } -BOOST_AUTO_TEST_CASE( insert_unsupportedModel ) +BOOST_AUTO_TEST_CASE(insert_unsupportedModel) { TestModule::ClassMap cm; - BOOST_REQUIRE_THROW(Slicer::SerializeAny<Slicer::SqlInsertSerializer>(cm, db, "converted"), Slicer::UnsupportedModelType); + BOOST_REQUIRE_THROW( + Slicer::SerializeAny<Slicer::SqlInsertSerializer>(cm, db, "converted"), Slicer::UnsupportedModelType); } BOOST_AUTO_TEST_SUITE_END(); - diff --git a/slicer/db/testMockCommon.cpp b/slicer/db/testMockCommon.cpp index ed18563..0d8c2c9 100644 --- a/slicer/db/testMockCommon.cpp +++ b/slicer/db/testMockCommon.cpp @@ -2,15 +2,8 @@ #include <definedDirs.h> StandardMockDatabase::StandardMockDatabase() : -DB::PluginMock<PQ::Mock>("pqmock", { - rootDir.parent_path() / "db" / "slicer.sql" }, - "user=postgres dbname=postgres") -{ -} - -ConnectionFixture::ConnectionFixture() : - _db(DB::MockDatabase::openConnectionTo("pqmock")), - db(_db.get()) + DB::PluginMock<PQ::Mock>("pqmock", {rootDir.parent_path() / "db" / "slicer.sql"}, "user=postgres dbname=postgres") { } +ConnectionFixture::ConnectionFixture() : _db(DB::MockDatabase::openConnectionTo("pqmock")), db(_db.get()) { } diff --git a/slicer/db/testMockCommon.h b/slicer/db/testMockCommon.h index bd9b11f..c775ae0 100644 --- a/slicer/db/testMockCommon.h +++ b/slicer/db/testMockCommon.h @@ -6,17 +6,16 @@ #include <visibility.h> class DLL_PUBLIC StandardMockDatabase : public DB::PluginMock<PQ::Mock> { - public: - StandardMockDatabase(); +public: + StandardMockDatabase(); }; class DLL_PUBLIC ConnectionFixture { - public: - ConnectionFixture(); +public: + ConnectionFixture(); - DB::ConnectionPtr _db; - DB::Connection * const db; + DB::ConnectionPtr _db; + DB::Connection * const db; }; #endif - diff --git a/slicer/db/testPatch.cpp b/slicer/db/testPatch.cpp index 2af60b4..70068e2 100644 --- a/slicer/db/testPatch.cpp +++ b/slicer/db/testPatch.cpp @@ -1,13 +1,13 @@ #define BOOST_TEST_MODULE db_patch -#include <boost/test/unit_test.hpp> -#include <boost/date_time/posix_time/posix_time_io.hpp> -#include "testMockCommon.h" -#include <slicer/slicer.h> -#include "sqlTablePatchSerializer.h" #include "sqlSelectDeserializer.h" -#include <types.h> +#include "sqlTablePatchSerializer.h" +#include "testMockCommon.h" +#include <boost/date_time/posix_time/posix_time_io.hpp> +#include <boost/test/unit_test.hpp> #include <common.h> +#include <slicer/slicer.h> #include <testModels.h> +#include <types.h> // LCOV_EXCL_START BOOST_TEST_DONT_PRINT_LOG_VALUE(TestModule::DateTime); @@ -16,16 +16,14 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(TestDatabase::Timespan); BOOST_TEST_DONT_PRINT_LOG_VALUE(DB::PrimaryKey); // LCOV_EXCL_STOP -BOOST_GLOBAL_FIXTURE( StandardMockDatabase ); +BOOST_GLOBAL_FIXTURE(StandardMockDatabase); BOOST_FIXTURE_TEST_SUITE(db, ConnectionFixture); -BOOST_AUTO_TEST_CASE( insert_builtins ) +BOOST_AUTO_TEST_CASE(insert_builtins) { - TestModule::BuiltInSeq bis = { - std::make_shared<TestModule::BuiltIns>(true, 5, 17, 0, 129, 2.3, 4.5, "more text"), - std::make_shared<TestModule::BuiltIns>(true, 6, 18, 0, 130, 3.4, 5.6, "even more text") - }; + TestModule::BuiltInSeq bis = {std::make_shared<TestModule::BuiltIns>(true, 5, 17, 0, 129, 2.3, 4.5, "more text"), + std::make_shared<TestModule::BuiltIns>(true, 6, 18, 0, 130, 3.4, 5.6, "even more text")}; DB::TablePatch tp; DB::TransactionScope tx(*db); tp.dest = "builtins"; @@ -42,4 +40,3 @@ BOOST_AUTO_TEST_CASE( insert_builtins ) } BOOST_AUTO_TEST_SUITE_END(); - diff --git a/slicer/db/testSelect.cpp b/slicer/db/testSelect.cpp index ce7821c..0e765f2 100644 --- a/slicer/db/testSelect.cpp +++ b/slicer/db/testSelect.cpp @@ -1,59 +1,58 @@ #define BOOST_TEST_MODULE db_select -#include <boost/test/unit_test.hpp> -#include <boost/date_time/posix_time/posix_time_io.hpp> -#include "testMockCommon.h" -#include <slicer/slicer.h> #include "sqlSelectDeserializer.h" -#include <types.h> +#include "testMockCommon.h" +#include <boost/date_time/posix_time/posix_time_io.hpp> +#include <boost/test/unit_test.hpp> #include <common.h> -#include <testModels.h> +#include <slicer/slicer.h> #include <sqlExceptions.h> +#include <testModels.h> +#include <types.h> using namespace std::literals; -BOOST_GLOBAL_FIXTURE( StandardMockDatabase ); +BOOST_GLOBAL_FIXTURE(StandardMockDatabase); BOOST_FIXTURE_TEST_SUITE(db, ConnectionFixture); -BOOST_AUTO_TEST_CASE( select_simple_int ) +BOOST_AUTO_TEST_CASE(select_simple_int) { auto sel = db->select("SELECT MAX(id) FROM test"); auto bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, Ice::Int>(sel.get()); BOOST_REQUIRE_EQUAL(4, bi); } -BOOST_AUTO_TEST_CASE( select_simple_double ) +BOOST_AUTO_TEST_CASE(select_simple_double) { auto sel = db->select("SELECT MAX(fl) FROM test"); auto bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, Ice::Double>(sel.get()); BOOST_REQUIRE_CLOSE(1234.1234, bi, 0.0001); } -BOOST_AUTO_TEST_CASE( select_simple_string ) +BOOST_AUTO_TEST_CASE(select_simple_string) { auto sel = db->select("SELECT MAX(string) FROM test"); auto bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, std::string>(sel.get()); BOOST_REQUIRE_EQUAL("text two", bi); } -BOOST_AUTO_TEST_CASE( select_simple_true ) +BOOST_AUTO_TEST_CASE(select_simple_true) { auto sel = db->select("SELECT true"); auto bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, bool>(sel.get()); BOOST_REQUIRE_EQUAL(true, bi); } -BOOST_AUTO_TEST_CASE( select_simple_false ) +BOOST_AUTO_TEST_CASE(select_simple_false) { auto sel = db->select("SELECT NOT(true)"); auto bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, bool>(sel.get()); BOOST_REQUIRE_EQUAL(false, bi); } -BOOST_AUTO_TEST_CASE( select_single ) +BOOST_AUTO_TEST_CASE(select_single) { - auto sel = db->select( - "SELECT boolean mbool, \ + auto sel = db->select("SELECT boolean mbool, \ id mbyte, id mshort, id mint, id mlong, \ fl mdouble, fl mfloat, \ string mstring \ @@ -72,10 +71,9 @@ BOOST_AUTO_TEST_CASE( select_single ) BOOST_REQUIRE_EQUAL("text one", bi->mstring); } -BOOST_AUTO_TEST_CASE( select_inherit_single ) +BOOST_AUTO_TEST_CASE(select_inherit_single) { - auto sel = db->select( - "SELECT id a, '::TestModule::D' || CAST(id AS TEXT) tc, 200 b, 300 c, 400 d \ + auto sel = db->select("SELECT id a, '::TestModule::D' || CAST(id AS TEXT) tc, 200 b, 300 c, 400 d \ FROM test \ WHERE id = 2"); auto bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestModule::BasePtr>(sel.get(), "tc"s); @@ -86,10 +84,9 @@ BOOST_AUTO_TEST_CASE( select_inherit_single ) BOOST_REQUIRE_EQUAL(300, d2->c); } -BOOST_AUTO_TEST_CASE( select_simple_sequence ) +BOOST_AUTO_TEST_CASE(select_simple_sequence) { - auto sel = db->select( - "SELECT string \ + auto sel = db->select("SELECT string \ FROM test \ ORDER BY id DESC"); auto bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestModule::SimpleSeq>(sel.get()); @@ -100,10 +97,9 @@ BOOST_AUTO_TEST_CASE( select_simple_sequence ) BOOST_REQUIRE_EQUAL("text one", bi[3]); } -BOOST_AUTO_TEST_CASE( select_inherit_sequence ) +BOOST_AUTO_TEST_CASE(select_inherit_sequence) { - auto sel = db->select( - "SELECT id a, '::TestModule::D' || CAST(id AS TEXT) tc, 200 b, 300 c, 400 d \ + auto sel = db->select("SELECT id a, '::TestModule::D' || CAST(id AS TEXT) tc, 200 b, 300 c, 400 d \ FROM test \ WHERE id < 4 \ ORDER BY id DESC"); @@ -124,13 +120,13 @@ BOOST_AUTO_TEST_CASE( select_inherit_sequence ) BOOST_REQUIRE_EQUAL(200, d1->b); } -BOOST_AUTO_TEST_CASE( select_inherit_datetime ) +BOOST_AUTO_TEST_CASE(select_inherit_datetime) { - auto sel = db->select( - "SELECT dt, to_char(dt, 'YYYY-MM-DD') date, ts \ + auto sel = db->select("SELECT dt, to_char(dt, 'YYYY-MM-DD') date, ts \ FROM test \ WHERE id = 3"); - TestDatabase::SpecificTypesPtr bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestDatabase::SpecificTypesPtr>(sel.get()); + TestDatabase::SpecificTypesPtr bi + = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestDatabase::SpecificTypesPtr>(sel.get()); BOOST_REQUIRE_EQUAL(2015, bi->dt.year); BOOST_REQUIRE_EQUAL(3, bi->dt.month); BOOST_REQUIRE_EQUAL(27, bi->dt.day); @@ -146,45 +142,45 @@ BOOST_AUTO_TEST_CASE( select_inherit_datetime ) BOOST_REQUIRE_EQUAL(12, bi->ts->seconds); } -template <typename T, typename ... P> +template<typename T, typename... P> T -BoostThrowWrapperHelper(P && ... p) +BoostThrowWrapperHelper(P &&... p) { return Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, T>(p...); } -BOOST_AUTO_TEST_CASE( select_unsupportedModel ) +BOOST_AUTO_TEST_CASE(select_unsupportedModel) { auto sel = db->select("SELECT id FROM test"); BOOST_REQUIRE_THROW(BoostThrowWrapperHelper<TestModule::ClassMap>(sel.get()), Slicer::UnsupportedModelType); } -BOOST_AUTO_TEST_CASE( select_tooManyRowsSimple ) +BOOST_AUTO_TEST_CASE(select_tooManyRowsSimple) { auto sel = db->select("SELECT id FROM test"); BOOST_REQUIRE_THROW(BoostThrowWrapperHelper<Ice::Int>(sel.get()), Slicer::TooManyRowsReturned); } -BOOST_AUTO_TEST_CASE( select_noRowsSimple ) +BOOST_AUTO_TEST_CASE(select_noRowsSimple) { auto sel = db->select("SELECT id FROM test WHERE false"); BOOST_REQUIRE_THROW(BoostThrowWrapperHelper<Ice::Int>(sel.get()), Slicer::NoRowsReturned); } -BOOST_AUTO_TEST_CASE( select_noRowsSimpleOptional ) +BOOST_AUTO_TEST_CASE(select_noRowsSimpleOptional) { auto sel = db->select("SELECT id FROM test WHERE false"); auto v = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, Ice::optional<Ice::Int>>(sel.get()); BOOST_REQUIRE(!v); } -BOOST_AUTO_TEST_CASE( select_tooManyRowsSimpleOptional ) +BOOST_AUTO_TEST_CASE(select_tooManyRowsSimpleOptional) { auto sel = db->select("SELECT id FROM test"); BOOST_REQUIRE_THROW(BoostThrowWrapperHelper<Ice::optional<Ice::Int>>(sel.get()), Slicer::TooManyRowsReturned); } -BOOST_AUTO_TEST_CASE( select_simpleOptional ) +BOOST_AUTO_TEST_CASE(select_simpleOptional) { auto sel = db->select("SELECT MAX(id) FROM test"); auto v = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, Ice::optional<Ice::Int>>(sel.get()); @@ -192,10 +188,9 @@ BOOST_AUTO_TEST_CASE( select_simpleOptional ) BOOST_REQUIRE_EQUAL(4, *v); } -BOOST_AUTO_TEST_CASE( select_noRowsComplexOptional ) +BOOST_AUTO_TEST_CASE(select_noRowsComplexOptional) { - auto sel = db->select( - "SELECT boolean mbool, \ + auto sel = db->select("SELECT boolean mbool, \ id mbyte, id mshort, id mint, id mlong, \ fl mdouble, fl mfloat, \ string mstring \ @@ -205,26 +200,26 @@ BOOST_AUTO_TEST_CASE( select_noRowsComplexOptional ) BOOST_REQUIRE(!v); } -BOOST_AUTO_TEST_CASE( select_tooManyRowsComplex ) +BOOST_AUTO_TEST_CASE(select_tooManyRowsComplex) { auto sel = db->select("SELECT id FROM test"); BOOST_REQUIRE_THROW(BoostThrowWrapperHelper<TestModule::BuiltInsPtr>(sel.get()), Slicer::TooManyRowsReturned); } -BOOST_AUTO_TEST_CASE( select_noRowsComplex ) +BOOST_AUTO_TEST_CASE(select_noRowsComplex) { auto sel = db->select("SELECT id FROM test WHERE false"); BOOST_REQUIRE_THROW(BoostThrowWrapperHelper<TestModule::BuiltInsPtr>(sel.get()), Slicer::NoRowsReturned); } -BOOST_AUTO_TEST_CASE( select_emptySequence ) +BOOST_AUTO_TEST_CASE(select_emptySequence) { auto sel = db->select("SELECT id FROM test WHERE false"); auto bi = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestModule::BaseSeq>(sel.get()); BOOST_REQUIRE_EQUAL(0, bi.size()); } -BOOST_AUTO_TEST_CASE( select_null ) +BOOST_AUTO_TEST_CASE(select_null) { db->execute("INSERT INTO test(id) VALUES(NULL)"); @@ -242,12 +237,12 @@ BOOST_AUTO_TEST_CASE( select_null ) BOOST_REQUIRE(!v); } -BOOST_AUTO_TEST_CASE( bulkSelectTest ) +BOOST_AUTO_TEST_CASE(bulkSelectTest) { - auto sel = db->select(R"SQL(select s mint, cast(s as numeric(7,1)) mdouble, cast(s as text) mstring, s % 2 = 0 mbool from generate_series(1, 10000) s)SQL"); + auto sel = db->select( + R"SQL(select s mint, cast(s as numeric(7,1)) mdouble, cast(s as text) mstring, s % 2 = 0 mbool from generate_series(1, 10000) s)SQL"); auto vec = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestDatabase::BuiltInSeq>(sel.get()); BOOST_REQUIRE_EQUAL(10000, vec.size()); } BOOST_AUTO_TEST_SUITE_END(); - diff --git a/slicer/db/testUpdate.cpp b/slicer/db/testUpdate.cpp index 48ea903..7dbcba3 100644 --- a/slicer/db/testUpdate.cpp +++ b/slicer/db/testUpdate.cpp @@ -1,29 +1,29 @@ #define BOOST_TEST_MODULE db_update -#include <boost/test/unit_test.hpp> -#include <boost/date_time/posix_time/posix_time_io.hpp> -#include "testMockCommon.h" -#include <slicer/slicer.h> #include "sqlInsertSerializer.h" #include "sqlSelectDeserializer.h" #include "sqlUpdateSerializer.h" -#include <types.h> +#include "testMockCommon.h" +#include <boost/date_time/posix_time/posix_time_io.hpp> +#include <boost/test/unit_test.hpp> #include <common.h> -#include <testModels.h> +#include <slicer/slicer.h> #include <sqlExceptions.h> +#include <testModels.h> +#include <types.h> using namespace std::literals; -BOOST_GLOBAL_FIXTURE( StandardMockDatabase ); +BOOST_GLOBAL_FIXTURE(StandardMockDatabase); BOOST_FIXTURE_TEST_SUITE(db, ConnectionFixture); -BOOST_AUTO_TEST_CASE( update_builtinsNotFound ) +BOOST_AUTO_TEST_CASE(update_builtinsNotFound) { TestModule::BuiltInsPtr ubi = std::make_shared<TestModule::BuiltIns>(false, 5, 17, 64, 129, -1.2, -1.4, "string"); BOOST_REQUIRE_THROW(Slicer::SerializeAny<Slicer::SqlUpdateSerializer>(ubi, db, "builtins"), Slicer::NoRowsFound); } -BOOST_AUTO_TEST_CASE( update_builtins ) +BOOST_AUTO_TEST_CASE(update_builtins) { TestModule::BuiltInsPtr bi1 = std::make_shared<TestModule::BuiltIns>(true, 4, 16, 64, 128, 1.2, 3.4, "text1"); TestModule::BuiltInsPtr bi2 = std::make_shared<TestModule::BuiltIns>(true, 3, 15, 63, 127, 5.2, 5.4, "text2"); @@ -54,12 +54,10 @@ BOOST_AUTO_TEST_CASE( update_builtins ) BOOST_REQUIRE_EQUAL(bis.back()->mstring, bi2->mstring); } -BOOST_AUTO_TEST_CASE( update_builtins_seq ) +BOOST_AUTO_TEST_CASE(update_builtins_seq) { - TestModule::BuiltInSeq ubis { - TestModule::BuiltInsPtr(std::make_shared<TestModule::BuiltIns>(false, 5, 17, 64, 128, -1.2, -1.4, "string")), - TestModule::BuiltInsPtr(std::make_shared<TestModule::BuiltIns>(false, 5, 21, 63, 127, -4.2, -5.4, "string updated")) - }; + TestModule::BuiltInSeq ubis {std::make_shared<TestModule::BuiltIns>(false, 5, 17, 64, 128, -1.2, -1.4, "string"), + std::make_shared<TestModule::BuiltIns>(false, 5, 21, 63, 127, -4.2, -5.4, "string updated")}; Slicer::SerializeAny<Slicer::SqlUpdateSerializer>(ubis, db, "builtins"); auto sel = db->select("SELECT * FROM builtins ORDER BY mint"); @@ -83,7 +81,7 @@ BOOST_AUTO_TEST_CASE( update_builtins_seq ) BOOST_REQUIRE_EQUAL(ubis.back()->mstring, ubis2.front()->mstring); } -BOOST_AUTO_TEST_CASE( update_withNulls ) +BOOST_AUTO_TEST_CASE(update_withNulls) { auto sel = db->select("SELECT * FROM builtins ORDER BY mint"); auto bis = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, TestDatabase::BuiltInSeq>(sel.get()); @@ -107,11 +105,11 @@ BOOST_AUTO_TEST_CASE( update_withNulls ) BOOST_REQUIRE(bis2[1]->mfloat); } -BOOST_AUTO_TEST_CASE( update_unsupportedModel ) +BOOST_AUTO_TEST_CASE(update_unsupportedModel) { TestModule::ClassMap cm; - BOOST_REQUIRE_THROW(Slicer::SerializeAny<Slicer::SqlUpdateSerializer>(cm, db, "converted"), Slicer::UnsupportedModelType); + BOOST_REQUIRE_THROW( + Slicer::SerializeAny<Slicer::SqlUpdateSerializer>(cm, db, "converted"), Slicer::UnsupportedModelType); } BOOST_AUTO_TEST_SUITE_END(); - diff --git a/slicer/ice/serializer.cpp b/slicer/ice/serializer.cpp index a2e6f4a..877f531 100644 --- a/slicer/ice/serializer.cpp +++ b/slicer/ice/serializer.cpp @@ -1,6 +1,6 @@ #include "serializer.h" -#include "Ice/Initialize.h" #include "Ice/Communicator.h" +#include "Ice/Initialize.h" NAMEDFACTORY("application/ice", Slicer::IceStreamSerializer, Slicer::StreamSerializerFactory); NAMEDFACTORY("application/ice", Slicer::IceStreamDeserializer, Slicer::StreamDeserializerFactory); @@ -8,19 +8,13 @@ NAMEDFACTORY("application/ice", Slicer::IceStreamDeserializer, Slicer::StreamDes namespace Slicer { Ice::StringSeq empty; - IceBase::IceBase() : - ic(Ice::initialize(empty)) - { - } + IceBase::IceBase() : ic(Ice::initialize(empty)) { } IceBase::~IceBase() { ic->destroy(); } - IceBlobSerializer::IceBlobSerializer(Ice::ByteSeq & b) : - blob(b) - { - } + IceBlobSerializer::IceBlobSerializer(Ice::ByteSeq & b) : blob(b) { } void IceBlobSerializer::Serialize(ModelPartForRootPtr mp) @@ -30,11 +24,7 @@ namespace Slicer { s.finished(blob); } - IceStreamSerializer::IceStreamSerializer(std::ostream & os) : - IceBlobSerializer(blob), - strm(os) - { - } + IceStreamSerializer::IceStreamSerializer(std::ostream & os) : IceBlobSerializer(blob), strm(os) { } void IceStreamSerializer::Serialize(ModelPartForRootPtr mp) @@ -43,10 +33,7 @@ namespace Slicer { strm.write((const char *)&blob.front(), blob.size()); } - IceBlobDeserializer::IceBlobDeserializer(const Ice::ByteSeq & b) : - blob(b) - { - } + IceBlobDeserializer::IceBlobDeserializer(const Ice::ByteSeq & b) : blob(b) { } void IceBlobDeserializer::Deserialize(ModelPartForRootPtr mp) @@ -55,11 +42,7 @@ namespace Slicer { mp->Read(s); } - IceStreamDeserializer::IceStreamDeserializer(std::istream & is) : - IceBlobDeserializer(blob), - strm(is) - { - } + IceStreamDeserializer::IceStreamDeserializer(std::istream & is) : IceBlobDeserializer(blob), strm(is) { } void IceStreamDeserializer::Deserialize(ModelPartForRootPtr mp) @@ -68,4 +51,3 @@ namespace Slicer { IceBlobDeserializer::Deserialize(mp); } } - diff --git a/slicer/ice/serializer.h b/slicer/ice/serializer.h index c1768c0..05a7752 100644 --- a/slicer/ice/serializer.h +++ b/slicer/ice/serializer.h @@ -1,65 +1,63 @@ #ifndef SLICER_ICE_H #define SLICER_ICE_H +#include <Ice/BuiltinSequences.h> +#include <Ice/CommunicatorF.h> #include <slicer/serializer.h> #include <visibility.h> -#include <Ice/CommunicatorF.h> -#include <Ice/BuiltinSequences.h> namespace Slicer { class IceBase { - public: - virtual ~IceBase(); + public: + virtual ~IceBase(); - protected: - IceBase(); + protected: + IceBase(); - Ice::CommunicatorPtr ic; + Ice::CommunicatorPtr ic; }; class DLL_PUBLIC IceBlobSerializer : public Serializer, protected IceBase { - public: - IceBlobSerializer(Ice::ByteSeq &); + public: + IceBlobSerializer(Ice::ByteSeq &); - void Serialize(ModelPartForRootPtr) override; + void Serialize(ModelPartForRootPtr) override; - private: - Ice::ByteSeq & blob; + private: + Ice::ByteSeq & blob; }; class DLL_PUBLIC IceStreamSerializer : public IceBlobSerializer { - public: - IceStreamSerializer(std::ostream &); + public: + IceStreamSerializer(std::ostream &); - void Serialize(ModelPartForRootPtr) override; + void Serialize(ModelPartForRootPtr) override; - protected: - std::ostream & strm; - Ice::ByteSeq blob; + protected: + std::ostream & strm; + Ice::ByteSeq blob; }; class DLL_PUBLIC IceBlobDeserializer : public Deserializer, protected IceBase { - public: - IceBlobDeserializer(const Ice::ByteSeq &); + public: + IceBlobDeserializer(const Ice::ByteSeq &); - void Deserialize(ModelPartForRootPtr) override; + void Deserialize(ModelPartForRootPtr) override; - protected: - const Ice::ByteSeq & blob; + protected: + const Ice::ByteSeq & blob; }; class DLL_PUBLIC IceStreamDeserializer : public IceBlobDeserializer { - public: - IceStreamDeserializer(std::istream &); + public: + IceStreamDeserializer(std::istream &); - void Deserialize(ModelPartForRootPtr) override; + void Deserialize(ModelPartForRootPtr) override; - protected: - std::istream & strm; - Ice::ByteSeq blob; + protected: + std::istream & strm; + Ice::ByteSeq blob; }; } #endif - - diff --git a/slicer/ice/testSpecifics.cpp b/slicer/ice/testSpecifics.cpp index 9832352..3a4be15 100644 --- a/slicer/ice/testSpecifics.cpp +++ b/slicer/ice/testSpecifics.cpp @@ -1,7 +1,7 @@ #define BOOST_TEST_MODULE ice_specifics +#include "serializer.h" #include <boost/test/unit_test.hpp> #include <slicer.h> -#include "serializer.h" #include <types.h> // LCOV_EXCL_START @@ -30,7 +30,7 @@ testCompare(const X & x, const std::function<bool(const X &, const X &)> & cmp) BOOST_REQUIRE(cmp(x, x2)); } -BOOST_AUTO_TEST_CASE( builtins ) +BOOST_AUTO_TEST_CASE(builtins) { testCompare<std::string>("some string value"); testCompare<bool>(true); @@ -65,7 +65,7 @@ testCompareOptional(const X & d) BOOST_REQUIRE_EQUAL(d, *x3); } -BOOST_AUTO_TEST_CASE( optionalBuiltins ) +BOOST_AUTO_TEST_CASE(optionalBuiltins) { testCompareOptional<std::string>("some string value"); testCompareOptional<bool>(true); @@ -84,9 +84,7 @@ BOOST_AUTO_TEST_CASE( optionalBuiltins ) testCompareOptional<Ice::Double>(3.14159); } - - -BOOST_AUTO_TEST_CASE( classes ) +BOOST_AUTO_TEST_CASE(classes) { TestModule::BuiltInsPtr x = std::make_shared<TestModule::BuiltIns>(); x->mbool = true; @@ -98,21 +96,15 @@ BOOST_AUTO_TEST_CASE( classes ) x->mdouble = 3423423423.42342342343; x->mstring = "sdfsf432423"; testCompare<TestModule::BuiltInsPtr>(x, [](const auto & a, const auto & b) { - return a->mbool == b->mbool - && a->mbyte == b->mbyte - && a->mshort == b->mshort - && a->mint == b->mint - && a->mlong == b->mlong - && a->mfloat == b->mfloat - && a->mdouble == b->mdouble - && a->mstring == b->mstring; + return a->mbool == b->mbool && a->mbyte == b->mbyte && a->mshort == b->mshort && a->mint == b->mint + && a->mlong == b->mlong && a->mfloat == b->mfloat && a->mdouble == b->mdouble + && a->mstring == b->mstring; }); } -BOOST_AUTO_TEST_CASE( structes ) +BOOST_AUTO_TEST_CASE(structes) { - TestModule::IsoDate date({ 2016, 10, 3 }); + TestModule::IsoDate date({2016, 10, 3}); testCompare(date); testCompareOptional(date); } - diff --git a/slicer/json/serializer.cpp b/slicer/json/serializer.cpp index b9b0c69..b94ae2e 100644 --- a/slicer/json/serializer.cpp +++ b/slicer/json/serializer.cpp @@ -1,11 +1,11 @@ #include "serializer.h" -#include <slicer/metadata.h> -#include <jsonpp.h> #include <boost/numeric/conversion/cast.hpp> -#include <functional> -#include <stdexcept> #include <fstream> +#include <functional> #include <glibmm/ustring.h> +#include <jsonpp.h> +#include <slicer/metadata.h> +#include <stdexcept> NAMEDFACTORY(".js", Slicer::JsonFileSerializer, Slicer::FileSerializerFactory); NAMEDFACTORY(".js", Slicer::JsonFileDeserializer, Slicer::FileDeserializerFactory); @@ -24,173 +24,188 @@ namespace Slicer { using namespace std::placeholders; class JsonValueSource : public ValueSource { - public: - explicit JsonValueSource(const json::Value & s) : - value(s) - { - } + public: + explicit JsonValueSource(const json::Value & s) : value(s) { } - void set(bool & v) const override - { - v = std::get<bool>(value); - } + void + set(bool & v) const override + { + v = std::get<bool>(value); + } - void set(Ice::Byte & v) const override - { - v = boost::numeric_cast<Ice::Byte>(std::get<json::Number>(value)); - } + void + set(Ice::Byte & v) const override + { + v = boost::numeric_cast<Ice::Byte>(std::get<json::Number>(value)); + } - void set(Ice::Short & v) const override - { - v = boost::numeric_cast<Ice::Short>(std::get<json::Number>(value)); - } + void + set(Ice::Short & v) const override + { + v = boost::numeric_cast<Ice::Short>(std::get<json::Number>(value)); + } - void set(Ice::Int & v) const override - { - v = boost::numeric_cast<Ice::Int>(std::get<json::Number>(value)); - } + void + set(Ice::Int & v) const override + { + v = boost::numeric_cast<Ice::Int>(std::get<json::Number>(value)); + } - void set(Ice::Long & v) const override - { - v = boost::numeric_cast<Ice::Long>(std::get<json::Number>(value)); - } + void + set(Ice::Long & v) const override + { + v = boost::numeric_cast<Ice::Long>(std::get<json::Number>(value)); + } - void set(Ice::Float & v) const override - { - v = boost::numeric_cast<Ice::Float>(std::get<json::Number>(value)); - } + void + set(Ice::Float & v) const override + { + v = boost::numeric_cast<Ice::Float>(std::get<json::Number>(value)); + } - void set(Ice::Double & v) const override - { - v = boost::numeric_cast<Ice::Double>(std::get<json::Number>(value)); - } + void + set(Ice::Double & v) const override + { + v = boost::numeric_cast<Ice::Double>(std::get<json::Number>(value)); + } - void set(std::string & v) const override - { - v = std::get<json::String>(value); - } + void + set(std::string & v) const override + { + v = std::get<json::String>(value); + } - private: - const json::Value & value; + private: + const json::Value & value; }; class JsonValueTarget : public ValueTarget { - public: - explicit JsonValueTarget(json::Value & t) : - target(t) - { - target = json::Null(); - } + public: + explicit JsonValueTarget(json::Value & t) : target(t) + { + target = json::Null(); + } - void get(const bool & value) const override - { - target = value; - } + void + get(const bool & value) const override + { + target = value; + } - void get(const Ice::Byte & value) const override - { - target = boost::numeric_cast<json::Number>(value); - } + void + get(const Ice::Byte & value) const override + { + target = boost::numeric_cast<json::Number>(value); + } - void get(const Ice::Short & value) const override - { - target = boost::numeric_cast<json::Number>(value); - } + void + get(const Ice::Short & value) const override + { + target = boost::numeric_cast<json::Number>(value); + } - void get(const Ice::Int & value) const override - { - target = boost::numeric_cast<json::Number>(value); - } + void + get(const Ice::Int & value) const override + { + target = boost::numeric_cast<json::Number>(value); + } - void get(const Ice::Long & value) const override - { - target = boost::numeric_cast<json::Number>(value); - } + void + get(const Ice::Long & value) const override + { + target = boost::numeric_cast<json::Number>(value); + } - void get(const Ice::Float & value) const override - { - target = boost::numeric_cast<json::Number>(value); - } + void + get(const Ice::Float & value) const override + { + target = boost::numeric_cast<json::Number>(value); + } - void get(const Ice::Double & value) const override - { - target = boost::numeric_cast<json::Number>(value); - } + void + get(const Ice::Double & value) const override + { + target = boost::numeric_cast<json::Number>(value); + } - void get(const std::string & value) const override - { - target = value; - } + void + get(const std::string & value) const override + { + target = value; + } - private: - json::Value & target; + private: + json::Value & target; }; class DocumentTreeIterate { - public: - explicit DocumentTreeIterate(ModelPartPtr & mp) : modelPart(mp) - { - } - template<typename SimpleT> - void operator()(const SimpleT & v) const - { - modelPart->Create(); - modelPart->SetValue(JsonValueSource(v)); - modelPart->Complete(); - } - void operator()(const json::Null &) const - { - modelPart->Complete(); - } - void operator()(const json::Object & o) const - { - if (auto typeIdName = modelPart->GetTypeIdProperty()) { - auto typeAttrItr = o.find(*typeIdName); - if (typeAttrItr != o.end() && std::holds_alternative<json::String>(typeAttrItr->second)) { - modelPart = modelPart->GetSubclassModelPart(std::get<json::String>(typeAttrItr->second)); - } - } - modelPart->Create(); - if (metaDataFlagSet(modelPart->GetMetadata(), md_object)) { - for (const auto & element : o) { - auto emp = modelPart->GetAnonChild(); - emp->Create(); - auto key = emp->GetChild(keyName); - auto value = emp->GetChild(valueName); - key->Create(); - key->SetValue(JsonValueSource(element.first)); - key->Complete(); - std::visit(DocumentTreeIterate(value), element.second); - emp->Complete(); - } - } - else { - for (const auto & element : o) { - auto emp = modelPart->GetChild(element.first); - if (emp) { - emp->Create(); - std::visit(DocumentTreeIterate(emp), element.second); - emp->Complete(); - } - } - modelPart->Complete(); + public: + explicit DocumentTreeIterate(ModelPartPtr & mp) : modelPart(mp) { } + template<typename SimpleT> + void + operator()(const SimpleT & v) const + { + modelPart->Create(); + modelPart->SetValue(JsonValueSource(v)); + modelPart->Complete(); + } + void + operator()(const json::Null &) const + { + modelPart->Complete(); + } + void + operator()(const json::Object & o) const + { + if (auto typeIdName = modelPart->GetTypeIdProperty()) { + auto typeAttrItr = o.find(*typeIdName); + if (typeAttrItr != o.end() && std::holds_alternative<json::String>(typeAttrItr->second)) { + modelPart = modelPart->GetSubclassModelPart(std::get<json::String>(typeAttrItr->second)); } } - void operator()(const json::Array & a) const - { - modelPart->Create(); - for (const auto & element : a) { + modelPart->Create(); + if (metaDataFlagSet(modelPart->GetMetadata(), md_object)) { + for (const auto & element : o) { auto emp = modelPart->GetAnonChild(); + emp->Create(); + auto key = emp->GetChild(keyName); + auto value = emp->GetChild(valueName); + key->Create(); + key->SetValue(JsonValueSource(element.first)); + key->Complete(); + std::visit(DocumentTreeIterate(value), element.second); + emp->Complete(); + } + } + else { + for (const auto & element : o) { + auto emp = modelPart->GetChild(element.first); if (emp) { emp->Create(); - std::visit(DocumentTreeIterate(emp), element); + std::visit(DocumentTreeIterate(emp), element.second); emp->Complete(); } } modelPart->Complete(); } - private: - ModelPartPtr & modelPart; + } + void + operator()(const json::Array & a) const + { + modelPart->Create(); + for (const auto & element : a) { + auto emp = modelPart->GetAnonChild(); + if (emp) { + emp->Create(); + std::visit(DocumentTreeIterate(emp), element); + emp->Complete(); + } + } + modelPart->Complete(); + } + + private: + ModelPartPtr & modelPart; }; void @@ -218,7 +233,7 @@ namespace Slicer { JsonValueSource s(kv); s.set(k); ModelTreeIterateRoot(&v, mp->GetChild(valueName)); - obj->insert({ k, v }); + obj->insert({k, v}); } void @@ -228,18 +243,17 @@ namespace Slicer { return; } switch (mp->GetType()) { - case mpt_Null: + case ModelPartType::Null: std::get<json::Object>(*n).insert({name, json::Null()}); return; - case mpt_Simple: - { - json::Value v; - if (mp->GetValue(JsonValueTarget(v))) { - std::get<json::Object>(*n).insert({ name, v }); - } - break; + case ModelPartType::Simple: { + json::Value v; + if (mp->GetValue(JsonValueTarget(v))) { + std::get<json::Object>(*n).insert({name, v}); } - case mpt_Complex: + break; + } + case ModelPartType::Complex: if (mp->HasValue()) { json::Object nn; if (auto typeIdName = mp->GetTypeIdProperty()) { @@ -248,35 +262,34 @@ namespace Slicer { mp = mp->GetSubclassModelPart(*typeId); } } - mp->OnEachChild( - [capture0 = &std::get<json::Object>(*n).insert({name, nn}).first->second] - (auto && PH1, auto && PH2, auto &&) { - return JsonSerializer::ModelTreeIterate(capture0, PH1, PH2); - }); + mp->OnEachChild([capture0 = &std::get<json::Object>(*n).insert({name, nn}).first->second]( + auto && PH1, auto && PH2, auto &&) { + return JsonSerializer::ModelTreeIterate(capture0, PH1, PH2); + }); } break; - case mpt_Sequence: + case ModelPartType::Sequence: if (mp->HasValue()) { mp->OnEachChild( - [capture0 = &std::get<json::Object>(*n).insert({name, json::Array()}).first->second] - (auto &&, auto && PH2, auto &&) { + [capture0 = &std::get<json::Object>(*n).insert({name, json::Array()}).first->second]( + auto &&, auto && PH2, auto &&) { return JsonSerializer::ModelTreeIterateSeq(capture0, PH2); }); } break; - case mpt_Dictionary: + case ModelPartType::Dictionary: if (mp->HasValue()) { if (metaDataFlagSet(mp->GetMetadata(), md_object)) { mp->OnEachChild( - [capture0 = &std::get<json::Object>(*n).insert({name, json::Object()}).first->second] - (auto &&, auto && PH2, auto &&) { + [capture0 = &std::get<json::Object>(*n).insert({name, json::Object()}).first->second]( + auto &&, auto && PH2, auto &&) { return JsonSerializer::ModelTreeIterateDictObj(capture0, PH2); }); } else { mp->OnEachChild( - [capture0 = &std::get<json::Object>(*n).insert({name, json::Array()}).first->second] - (auto &&, auto && PH2, auto &&) { + [capture0 = &std::get<json::Object>(*n).insert({name, json::Array()}).first->second]( + auto &&, auto && PH2, auto &&) { return JsonSerializer::ModelTreeIterateSeq(capture0, PH2); }); } @@ -290,13 +303,13 @@ namespace Slicer { { if (mp) { switch (mp->GetType()) { - case mpt_Null: + case ModelPartType::Null: *n = json::Null(); return; - case mpt_Simple: + case ModelPartType::Simple: mp->GetValue(JsonValueTarget(*n)); break; - case mpt_Complex: + case ModelPartType::Complex: *n = json::Object(); if (auto typeIdName = mp->GetTypeIdProperty()) { if (auto typeId = mp->GetTypeId()) { @@ -308,13 +321,13 @@ namespace Slicer { return JsonSerializer::ModelTreeIterate(n, PH1, PH2); }); break; - case mpt_Sequence: + case ModelPartType::Sequence: *n = json::Array(); mp->OnEachChild([n](auto &&, auto && PH2, auto &&) { return JsonSerializer::ModelTreeIterateSeq(n, PH2); }); break; - case mpt_Dictionary: + case ModelPartType::Dictionary: if (metaDataFlagSet(mp->GetMetadata(), md_object)) { *n = json::Object(); mp->OnEachChild([n](auto &&, auto && PH2, auto &&) { @@ -332,15 +345,9 @@ namespace Slicer { } } - JsonStreamSerializer::JsonStreamSerializer(std::ostream & s) : - strm(s) - { - } + JsonStreamSerializer::JsonStreamSerializer(std::ostream & s) : strm(s) { } - JsonStreamDeserializer::JsonStreamDeserializer(std::istream & s) : - strm(s) - { - } + JsonStreamDeserializer::JsonStreamDeserializer(std::istream & s) : strm(s) { } void JsonStreamDeserializer::Deserialize(ModelPartForRootPtr modelRoot) @@ -360,15 +367,9 @@ namespace Slicer { json::serializeValue(doc, strm, "utf-8"); } - JsonFileSerializer::JsonFileSerializer(std::filesystem::path p) : - path(std::move(p)) - { - } + JsonFileSerializer::JsonFileSerializer(std::filesystem::path p) : path(std::move(p)) { } - JsonFileDeserializer::JsonFileDeserializer(std::filesystem::path p) : - path(std::move(p)) - { - } + JsonFileDeserializer::JsonFileDeserializer(std::filesystem::path p) : path(std::move(p)) { } void JsonFileDeserializer::Deserialize(ModelPartForRootPtr modelRoot) @@ -390,15 +391,9 @@ namespace Slicer { json::serializeValue(doc, outFile, "utf-8"); } - JsonValueSerializer::JsonValueSerializer(json::Value & v) : - value(v) - { - } + JsonValueSerializer::JsonValueSerializer(json::Value & v) : value(v) { } - JsonValueDeserializer::JsonValueDeserializer(const json::Value & v) : - value(v) - { - } + JsonValueDeserializer::JsonValueDeserializer(const json::Value & v) : value(v) { } void JsonValueDeserializer::Deserialize(ModelPartForRootPtr modelRoot) @@ -415,5 +410,3 @@ namespace Slicer { }); } } - - diff --git a/slicer/json/serializer.h b/slicer/json/serializer.h index ed666aa..c23121b 100644 --- a/slicer/json/serializer.h +++ b/slicer/json/serializer.h @@ -1,80 +1,78 @@ #ifndef SLICER_JSON_H #define SLICER_JSON_H -#include <slicer/serializer.h> #include <jsonpp.h> +#include <slicer/serializer.h> #include <visibility.h> namespace Slicer { class JsonSerializer : public Serializer { - protected: - static void ModelTreeIterate(json::Value *, const std::string &, ModelPartPtr mp); - static void ModelTreeIterateDictObj(json::Value *, const ModelPartPtr & mp); - static void ModelTreeIterateSeq(json::Value *, const ModelPartPtr & mp); - static void ModelTreeIterateRoot(json::Value *, ModelPartPtr mp); + protected: + static void ModelTreeIterate(json::Value *, const std::string &, ModelPartPtr mp); + static void ModelTreeIterateDictObj(json::Value *, const ModelPartPtr & mp); + static void ModelTreeIterateSeq(json::Value *, const ModelPartPtr & mp); + static void ModelTreeIterateRoot(json::Value *, ModelPartPtr mp); }; class DLL_PUBLIC JsonStreamSerializer : public JsonSerializer { - public: - JsonStreamSerializer(std::ostream &); + public: + explicit JsonStreamSerializer(std::ostream &); - void Serialize(ModelPartForRootPtr) override; + void Serialize(ModelPartForRootPtr) override; - protected: - std::ostream & strm; + protected: + std::ostream & strm; }; class DLL_PUBLIC JsonFileSerializer : public JsonSerializer { - public: - JsonFileSerializer(std::filesystem::path); + public: + explicit JsonFileSerializer(std::filesystem::path); - void Serialize(ModelPartForRootPtr) override; + void Serialize(ModelPartForRootPtr) override; - protected: - const std::filesystem::path path; + protected: + const std::filesystem::path path; }; class DLL_PUBLIC JsonValueSerializer : public JsonSerializer { - public: - JsonValueSerializer(json::Value &); + public: + explicit JsonValueSerializer(json::Value &); - void Serialize(ModelPartForRootPtr) override; + void Serialize(ModelPartForRootPtr) override; - protected: - json::Value & value; + protected: + json::Value & value; }; class DLL_PUBLIC JsonStreamDeserializer : public Deserializer { - public: - JsonStreamDeserializer(std::istream &); + public: + explicit JsonStreamDeserializer(std::istream &); - void Deserialize(ModelPartForRootPtr) override; + void Deserialize(ModelPartForRootPtr) override; - protected: - std::istream & strm; + protected: + std::istream & strm; }; class DLL_PUBLIC JsonFileDeserializer : public Deserializer { - public: - JsonFileDeserializer(std::filesystem::path); + public: + explicit JsonFileDeserializer(std::filesystem::path); - void Deserialize(ModelPartForRootPtr) override; + void Deserialize(ModelPartForRootPtr) override; - protected: - const std::filesystem::path path; + protected: + const std::filesystem::path path; }; class DLL_PUBLIC JsonValueDeserializer : public Deserializer { - public: - JsonValueDeserializer(const json::Value &); + public: + explicit JsonValueDeserializer(const json::Value &); - void Deserialize(ModelPartForRootPtr) override; + void Deserialize(ModelPartForRootPtr) override; - protected: - const json::Value & value; + protected: + const json::Value & value; }; } #endif - - diff --git a/slicer/json/testSpecifics.cpp b/slicer/json/testSpecifics.cpp index c0a54d4..6bfc9d4 100644 --- a/slicer/json/testSpecifics.cpp +++ b/slicer/json/testSpecifics.cpp @@ -1,18 +1,21 @@ #define BOOST_TEST_MODULE json_specifics +#include "serializer.h" #include <boost/test/unit_test.hpp> #include <slicer/slicer.h> -#include "serializer.h" #include <types.h> -BOOST_AUTO_TEST_CASE( factories ) +BOOST_AUTO_TEST_CASE(factories) { BOOST_REQUIRE(Slicer::SerializerPtr(Slicer::FileSerializerFactory::createNew(".json", "/some.json"))); BOOST_REQUIRE(Slicer::DeserializerPtr(Slicer::FileDeserializerFactory::createNew(".json", "/some.json"))); BOOST_REQUIRE(Slicer::SerializerPtr(Slicer::FileSerializerFactory::createNew(".js", "/some.js"))); BOOST_REQUIRE(Slicer::DeserializerPtr(Slicer::FileDeserializerFactory::createNew(".js", "/some.js"))); - BOOST_REQUIRE(Slicer::SerializerPtr(Slicer::StreamSerializerFactory::createNew("application/javascript", std::cout))); - BOOST_REQUIRE(Slicer::DeserializerPtr(Slicer::StreamDeserializerFactory::createNew("application/javascript", std::cin))); - BOOST_REQUIRE(Slicer::SerializerPtr(Slicer::StreamSerializerFactory::createNew("application/javascript", std::cout))); - BOOST_REQUIRE(Slicer::DeserializerPtr(Slicer::StreamDeserializerFactory::createNew("application/javascript", std::cin))); + BOOST_REQUIRE( + Slicer::SerializerPtr(Slicer::StreamSerializerFactory::createNew("application/javascript", std::cout))); + BOOST_REQUIRE( + Slicer::DeserializerPtr(Slicer::StreamDeserializerFactory::createNew("application/javascript", std::cin))); + BOOST_REQUIRE( + Slicer::SerializerPtr(Slicer::StreamSerializerFactory::createNew("application/javascript", std::cout))); + BOOST_REQUIRE( + Slicer::DeserializerPtr(Slicer::StreamDeserializerFactory::createNew("application/javascript", std::cin))); } - diff --git a/slicer/slicer/metadata.cpp b/slicer/slicer/metadata.cpp index 4f794fc..6429cc8 100644 --- a/slicer/slicer/metadata.cpp +++ b/slicer/slicer/metadata.cpp @@ -1,7 +1,7 @@ #include "metadata.h" +#include <boost/algorithm/string/classification.hpp> #include <boost/algorithm/string/predicate.hpp> #include <boost/algorithm/string/split.hpp> -#include <boost/algorithm/string/classification.hpp> bool Slicer::metaDataFlagSet(const std::list<std::string> & md, const std::string & flag) @@ -46,4 +46,3 @@ Slicer::metaDataValue(const std::string & prefix, const std::list<std::string> & } return std::optional<std::string>(); } - diff --git a/slicer/slicer/metadata.h b/slicer/slicer/metadata.h index 79baf13..e604658 100644 --- a/slicer/slicer/metadata.h +++ b/slicer/slicer/metadata.h @@ -1,10 +1,10 @@ #ifndef SLICER_METADATA_H #define SLICER_METADATA_H -#include <string> #include <list> -#include <vector> #include <optional> +#include <string> +#include <vector> namespace Slicer { #pragma GCC visibility push(default) @@ -19,4 +19,3 @@ namespace Slicer { } #endif - diff --git a/slicer/slicer/modelParts.cpp b/slicer/slicer/modelParts.cpp index 61cbd25..a6e191a 100644 --- a/slicer/slicer/modelParts.cpp +++ b/slicer/slicer/modelParts.cpp @@ -73,10 +73,7 @@ namespace Slicer { return shared_from_this(); } - HookCommon::HookCommon(std::string n) : - name(std::move(n)) - { - } + HookCommon::HookCommon(std::string n) : name(std::move(n)) { } bool HookCommon::filter(const HookFilter & flt) @@ -90,4 +87,3 @@ namespace Slicer { ch(this->name, modelPart, this); } } - diff --git a/slicer/slicer/modelParts.h b/slicer/slicer/modelParts.h index f31a8c0..50ae427 100644 --- a/slicer/slicer/modelParts.h +++ b/slicer/slicer/modelParts.h @@ -1,64 +1,62 @@ #ifndef SLICER_MODELPARTS_H #define SLICER_MODELPARTS_H -#include <Ice/Optional.h> #include <Ice/InputStream.h> +#include <Ice/Optional.h> #include <Ice/OutputStream.h> -#include <stdexcept> #include <functional> -#include <vector> #include <list> +#include <stdexcept> +#include <vector> #include <visibility.h> namespace Slicer { - template <typename T> - class TValueTarget { - public: - virtual void get(const T &) const = 0; + template<typename T> class TValueTarget { + public: + virtual void get(const T &) const = 0; }; class ValueTarget : - public TValueTarget<bool>, - public TValueTarget<Ice::Byte>, - public TValueTarget<Ice::Short>, - public TValueTarget<Ice::Int>, - public TValueTarget<Ice::Long>, - public TValueTarget<Ice::Float>, - public TValueTarget<Ice::Double>, - public TValueTarget<std::string> { - public: - using TValueTarget<bool>::get; - using TValueTarget<Ice::Byte>::get; - using TValueTarget<Ice::Short>::get; - using TValueTarget<Ice::Int>::get; - using TValueTarget<Ice::Long>::get; - using TValueTarget<Ice::Float>::get; - using TValueTarget<Ice::Double>::get; - using TValueTarget<std::string>::get; + public TValueTarget<bool>, + public TValueTarget<Ice::Byte>, + public TValueTarget<Ice::Short>, + public TValueTarget<Ice::Int>, + public TValueTarget<Ice::Long>, + public TValueTarget<Ice::Float>, + public TValueTarget<Ice::Double>, + public TValueTarget<std::string> { + public: + using TValueTarget<bool>::get; + using TValueTarget<Ice::Byte>::get; + using TValueTarget<Ice::Short>::get; + using TValueTarget<Ice::Int>::get; + using TValueTarget<Ice::Long>::get; + using TValueTarget<Ice::Float>::get; + using TValueTarget<Ice::Double>::get; + using TValueTarget<std::string>::get; }; - template <typename T> - class TValueSource { - public: - virtual void set(T &) const = 0; + template<typename T> class TValueSource { + public: + virtual void set(T &) const = 0; }; class ValueSource : - public TValueSource<bool>, - public TValueSource<Ice::Byte>, - public TValueSource<Ice::Short>, - public TValueSource<Ice::Int>, - public TValueSource<Ice::Long>, - public TValueSource<Ice::Float>, - public TValueSource<Ice::Double>, - public TValueSource<std::string> { - public: - using TValueSource<bool>::set; - using TValueSource<Ice::Byte>::set; - using TValueSource<Ice::Short>::set; - using TValueSource<Ice::Int>::set; - using TValueSource<Ice::Long>::set; - using TValueSource<Ice::Float>::set; - using TValueSource<Ice::Double>::set; - using TValueSource<std::string>::set; + public TValueSource<bool>, + public TValueSource<Ice::Byte>, + public TValueSource<Ice::Short>, + public TValueSource<Ice::Int>, + public TValueSource<Ice::Long>, + public TValueSource<Ice::Float>, + public TValueSource<Ice::Double>, + public TValueSource<std::string> { + public: + using TValueSource<bool>::set; + using TValueSource<Ice::Byte>::set; + using TValueSource<Ice::Short>::set; + using TValueSource<Ice::Int>::set; + using TValueSource<Ice::Long>::set; + using TValueSource<Ice::Float>::set; + using TValueSource<Ice::Double>::set; + using TValueSource<std::string>::set; }; class ModelPart; @@ -75,51 +73,51 @@ namespace Slicer { using Metadata = std::list<std::string>; DLL_PUBLIC extern const Metadata emptyMetadata; - enum ModelPartType { - mpt_Null, - mpt_Simple, - mpt_Complex, - mpt_Sequence, - mpt_Dictionary, + enum class ModelPartType { + Null, + Simple, + Complex, + Sequence, + Dictionary, }; - enum TryConvertResult { - tcr_NoAction = 0, - tcr_NoValue, - tcr_Value, + enum class TryConvertResult { + NoAction, + NoValue, + Value, }; class DLL_PUBLIC ChildRef { - public: - explicit ChildRef(); - explicit ChildRef(ModelPartPtr); - explicit ChildRef(ModelPartPtr, const Metadata &); - - [[nodiscard]] ModelPartPtr Child() const; - [[nodiscard]] const Metadata & ChildMetaData() const; - explicit operator bool() const; - - private: - ModelPartPtr mpp; - const Metadata & mdr; + public: + explicit ChildRef(); + explicit ChildRef(ModelPartPtr); + explicit ChildRef(ModelPartPtr, const Metadata &); + + [[nodiscard]] ModelPartPtr Child() const; + [[nodiscard]] const Metadata & ChildMetaData() const; + explicit operator bool() const; + + private: + ModelPartPtr mpp; + const Metadata & mdr; }; class DLL_PUBLIC HookCommon { - public: - explicit HookCommon(std::string); + public: + explicit HookCommon(std::string); - bool filter(const HookFilter & flt); - void apply(const ChildHandler & ch, const ModelPartPtr & modelPart); + bool filter(const HookFilter & flt); + void apply(const ChildHandler & ch, const ModelPartPtr & modelPart); - [[nodiscard]] virtual const Metadata & GetMetadata() const = 0; + [[nodiscard]] virtual const Metadata & GetMetadata() const = 0; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - const std::string name; + const std::string name; }; struct case_less { template<typename A, typename B> - inline bool operator()(const A & a, const B & b) const + inline bool + operator()(const A & a, const B & b) const { const auto cmp = strncasecmp(a.data(), b.data(), std::min(a.length(), b.length())); return (cmp < 0) || (!cmp && a.length() < b.length()); @@ -127,69 +125,64 @@ namespace Slicer { }; class DLL_PUBLIC ModelPart : public std::enable_shared_from_this<ModelPart> { - public: - ModelPart() = default; - ModelPart(const ModelPart &) = delete; - ModelPart(ModelPart &&) = delete; - - virtual ~ModelPart() = default; - - ModelPart & operator=(const ModelPart &) = delete; - ModelPart & operator=(ModelPart &&) = delete; - - template<typename T> - static ModelPartPtr CreateFor(); - template<typename T> - static ModelPartPtr CreateFor(T & t); - template<typename T> - static ModelPartForRootPtr CreateRootFor(T & t); - - virtual void OnEachChild(const ChildHandler &) = 0; - ModelPartPtr GetAnonChild(const HookFilter & = HookFilter()); - ModelPartPtr GetChild(const std::string & memberName, const HookFilter & = HookFilter()); - virtual ChildRef GetAnonChildRef(const HookFilter & = HookFilter()) = 0; - virtual ChildRef GetChildRef(const std::string & memberName, const HookFilter & = HookFilter(), bool matchCase = true) = 0; - virtual ModelPartPtr GetSubclassModelPart(const std::string &); - virtual TypeId GetTypeId() const; - virtual Ice::optional<std::string> GetTypeIdProperty() const; - virtual ModelPartType GetType() const = 0; - virtual void Create(); - virtual void Complete(); - virtual void SetValue(ValueSource &&); - virtual bool GetValue(ValueTarget &&); - virtual bool HasValue() const = 0; - virtual const Metadata & GetMetadata() const; - virtual bool IsOptional() const; - virtual ModelPartPtr GetContainedModelPart(); + public: + ModelPart() = default; + ModelPart(const ModelPart &) = delete; + ModelPart(ModelPart &&) = delete; + + virtual ~ModelPart() = default; + + ModelPart & operator=(const ModelPart &) = delete; + ModelPart & operator=(ModelPart &&) = delete; + + template<typename T> static ModelPartPtr CreateFor(); + template<typename T> static ModelPartPtr CreateFor(T & t); + template<typename T> static ModelPartForRootPtr CreateRootFor(T & t); + + virtual void OnEachChild(const ChildHandler &) = 0; + ModelPartPtr GetAnonChild(const HookFilter & = HookFilter()); + ModelPartPtr GetChild(const std::string & memberName, const HookFilter & = HookFilter()); + virtual ChildRef GetAnonChildRef(const HookFilter & = HookFilter()) = 0; + virtual ChildRef GetChildRef( + const std::string & memberName, const HookFilter & = HookFilter(), bool matchCase = true) + = 0; + virtual ModelPartPtr GetSubclassModelPart(const std::string &); + virtual TypeId GetTypeId() const; + virtual Ice::optional<std::string> GetTypeIdProperty() const; + virtual ModelPartType GetType() const = 0; + virtual void Create(); + virtual void Complete(); + virtual void SetValue(ValueSource &&); + virtual bool GetValue(ValueTarget &&); + virtual bool HasValue() const = 0; + virtual const Metadata & GetMetadata() const; + virtual bool IsOptional() const; + virtual ModelPartPtr GetContainedModelPart(); }; - template<typename T> - class DLL_PUBLIC ModelPartModel { - protected: - explicit ModelPartModel() : Model(nullptr) { } - explicit ModelPartModel(T * m) : Model(m) { } - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - T * Model; + template<typename T> class DLL_PUBLIC ModelPartModel { + protected: + explicit ModelPartModel() : Model(nullptr) { } + explicit ModelPartModel(T * m) : Model(m) { } + T * Model; }; class DLL_PUBLIC ModelPartForRootBase : public ModelPart { - public: - explicit ModelPartForRootBase(ModelPartPtr mp); - - virtual const std::string & GetRootName() const = 0; - ChildRef GetAnonChildRef(const HookFilter &) override; - ChildRef GetChildRef(const std::string & name, const HookFilter &, bool matchCase = true) override; - void OnEachChild(const ChildHandler & ch) override; - ModelPartType GetType() const override; - bool IsOptional() const override; - virtual void Write(::Ice::OutputStream &) const = 0; - virtual void Read(::Ice::InputStream &) = 0; - ModelPartPtr GetContainedModelPart() override; - - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - ModelPartPtr mp; + public: + explicit ModelPartForRootBase(ModelPartPtr mp); + + virtual const std::string & GetRootName() const = 0; + ChildRef GetAnonChildRef(const HookFilter &) override; + ChildRef GetChildRef(const std::string & name, const HookFilter &, bool matchCase = true) override; + void OnEachChild(const ChildHandler & ch) override; + ModelPartType GetType() const override; + bool IsOptional() const override; + virtual void Write(::Ice::OutputStream &) const = 0; + virtual void Read(::Ice::InputStream &) = 0; + ModelPartPtr GetContainedModelPart() override; + + ModelPartPtr mp; }; } #endif - diff --git a/slicer/slicer/modelPartsTypes.cpp b/slicer/slicer/modelPartsTypes.cpp index 7d9ea54..73e13bf 100644 --- a/slicer/slicer/modelPartsTypes.cpp +++ b/slicer/slicer/modelPartsTypes.cpp @@ -6,25 +6,29 @@ namespace Slicer { using ClassRefMap = std::map<std::string, ClassRef, std::less<>>; using ClassNamePair = std::pair<std::string, std::string>; - using ClassNameMap = boost::multi_index_container< - ClassNamePair, - boost::multi_index::indexed_by< - boost::multi_index::ordered_unique<boost::multi_index::member<ClassNamePair, const std::string, &ClassNamePair::first>, std::less<>>, - boost::multi_index::ordered_unique<boost::multi_index::member<ClassNamePair, const std::string, &ClassNamePair::second>, std::less<>> - >>; + using ClassNameMap = boost::multi_index_container<ClassNamePair, + boost::multi_index::indexed_by< + boost::multi_index::ordered_unique< + boost::multi_index::member<ClassNamePair, const std::string, &ClassNamePair::first>, + std::less<>>, + boost::multi_index::ordered_unique< + boost::multi_index::member<ClassNamePair, const std::string, &ClassNamePair::second>, + std::less<>>>>; static void createClassMaps() __attribute__((constructor(208))); static void deleteClassMaps() __attribute__((destructor(208))); static ClassNameMap * names; static ClassRefMap * refs; - void createClassMaps() + void + createClassMaps() { names = new ClassNameMap(); refs = new ClassRefMap(); } - static void deleteClassMaps() + static void + deleteClassMaps() { delete names; delete refs; @@ -100,10 +104,7 @@ namespace Slicer { } // ModelPartForRootBase - ModelPartForRootBase::ModelPartForRootBase(ModelPartPtr m) : - mp(std::move(m)) - { - } + ModelPartForRootBase::ModelPartForRootBase(ModelPartPtr m) : mp(std::move(m)) { } ChildRef ModelPartForRootBase::GetAnonChildRef(const HookFilter &) @@ -121,7 +122,8 @@ namespace Slicer { return GetAnonChildRef(hf); } - void ModelPartForRootBase::OnEachChild(const ChildHandler & ch) + void + ModelPartForRootBase::OnEachChild(const ChildHandler & ch) { ch(GetRootName(), mp, nullptr); } @@ -144,37 +146,83 @@ namespace Slicer { return mp->GetContainedModelPart(); } - void ModelPartForSimpleBase::OnEachChild(const ChildHandler &) { } - ChildRef ModelPartForSimpleBase::GetAnonChildRef(const HookFilter &) { return ChildRef(); } - ChildRef ModelPartForSimpleBase::GetChildRef(const std::string &, const HookFilter &, bool) { return ChildRef(); } - bool ModelPartForSimpleBase::HasValue() const { return true; } - ModelPartType ModelPartForSimpleBase::GetType() const { return type; } - const ModelPartType ModelPartForSimpleBase::type = mpt_Simple; + void + ModelPartForSimpleBase::OnEachChild(const ChildHandler &) + { + } + ChildRef + ModelPartForSimpleBase::GetAnonChildRef(const HookFilter &) + { + return ChildRef(); + } + ChildRef + ModelPartForSimpleBase::GetChildRef(const std::string &, const HookFilter &, bool) + { + return ChildRef(); + } + bool + ModelPartForSimpleBase::HasValue() const + { + return true; + } + ModelPartType + ModelPartForSimpleBase::GetType() const + { + return type; + } + const ModelPartType ModelPartForSimpleBase::type = ModelPartType::Simple; - void ModelPartForConvertedBase::OnEachChild(const ChildHandler &) { } - ChildRef ModelPartForConvertedBase::GetAnonChildRef(const HookFilter &) { return ChildRef(); } - ChildRef ModelPartForConvertedBase::GetChildRef(const std::string &, const HookFilter &, bool) { return ChildRef(); } - bool ModelPartForConvertedBase::HasValue() const { return true; } - ModelPartType ModelPartForConvertedBase::GetType() const { return type; } - const ModelPartType ModelPartForConvertedBase::type = mpt_Simple; + void + ModelPartForConvertedBase::OnEachChild(const ChildHandler &) + { + } + ChildRef + ModelPartForConvertedBase::GetAnonChildRef(const HookFilter &) + { + return ChildRef(); + } + ChildRef + ModelPartForConvertedBase::GetChildRef(const std::string &, const HookFilter &, bool) + { + return ChildRef(); + } + bool + ModelPartForConvertedBase::HasValue() const + { + return true; + } + ModelPartType + ModelPartForConvertedBase::GetType() const + { + return type; + } + const ModelPartType ModelPartForConvertedBase::type = ModelPartType::Simple; - ModelPartType ModelPartForComplexBase::GetType() const { return type; } - const ModelPartType ModelPartForComplexBase::type = mpt_Complex; - void ModelPartForComplexBase::registerClass(const std::string & className, const std::string * typeName, const ClassRef & cr) + ModelPartType + ModelPartForComplexBase::GetType() const { - Slicer::classRefMap()->insert({ className, cr }); + return type; + } + const ModelPartType ModelPartForComplexBase::type = ModelPartType::Complex; + void + ModelPartForComplexBase::registerClass( + const std::string & className, const std::string * typeName, const ClassRef & cr) + { + Slicer::classRefMap()->insert({className, cr}); if (typeName) { - Slicer::classNameMap()->insert({ className, *typeName }); + Slicer::classNameMap()->insert({className, *typeName}); } } - void ModelPartForComplexBase::unregisterClass(const std::string & className, const std::string * typeName) + void + ModelPartForComplexBase::unregisterClass(const std::string & className, const std::string * typeName) { Slicer::classRefMap()->erase(className); if (typeName) { classNameMap()->get<0>().erase(className); } } - ModelPartPtr ModelPartForComplexBase::getSubclassModelPart(const std::string & name, void * m) + ModelPartPtr + ModelPartForComplexBase::getSubclassModelPart(const std::string & name, void * m) { auto ref = classRefMap()->find(ToModelTypeName(name)); if (ref == classRefMap()->end()) { @@ -182,32 +230,38 @@ namespace Slicer { } return ref->second(m); } - TypeId ModelPartForComplexBase::GetTypeId(const std::string & id, const std::string & className) + TypeId + ModelPartForComplexBase::GetTypeId(const std::string & id, const std::string & className) { return (id == className) ? TypeId() : ToExchangeTypeName(id); } - std::string ModelPartForComplexBase::demangle(const char * mangled) + std::string + ModelPartForComplexBase::demangle(const char * mangled) { - auto buf = std::unique_ptr<char, decltype(free)*>(abi::__cxa_demangle(mangled, nullptr, nullptr, nullptr), std::free); + auto buf = std::unique_ptr<char, decltype(free) *>( + abi::__cxa_demangle(mangled, nullptr, nullptr, nullptr), std::free); return "::" + std::string(buf.get()); } - void ModelPartForOptionalBase::OnEachChild(const ChildHandler & ch) + void + ModelPartForOptionalBase::OnEachChild(const ChildHandler & ch) { if (this->hasModel()) { modelPart->OnEachChild(ch); } } - void ModelPartForOptionalBase::Complete() + void + ModelPartForOptionalBase::Complete() { if (this->hasModel()) { modelPart->Complete(); } } - ChildRef ModelPartForOptionalBase::GetAnonChildRef(const HookFilter & flt) + ChildRef + ModelPartForOptionalBase::GetAnonChildRef(const HookFilter & flt) { if (this->hasModel()) { return modelPart->GetAnonChildRef(flt); @@ -215,7 +269,8 @@ namespace Slicer { return ChildRef(); } - ChildRef ModelPartForOptionalBase::GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase) + ChildRef + ModelPartForOptionalBase::GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase) { if (this->hasModel()) { return modelPart->GetChildRef(name, flt, matchCase); @@ -223,57 +278,127 @@ namespace Slicer { return ChildRef(); } - void ModelPartForOptionalBase::SetValue(ValueSource && s) + void + ModelPartForOptionalBase::SetValue(ValueSource && s) { if (this->hasModel()) { modelPart->SetValue(std::move(s)); } } - bool ModelPartForOptionalBase::HasValue() const + bool + ModelPartForOptionalBase::HasValue() const { return this->hasModel() && modelPart->HasValue(); } - bool ModelPartForOptionalBase::IsOptional() const + bool + ModelPartForOptionalBase::IsOptional() const { return true; }; - const Metadata & ModelPartForOptionalBase::GetMetadata() const + const Metadata & + ModelPartForOptionalBase::GetMetadata() const { return modelPart->GetMetadata(); } - void ModelPartForEnumBase::OnEachChild(const ChildHandler &) { } - ChildRef ModelPartForEnumBase::GetAnonChildRef(const HookFilter &) { return ChildRef(); } - ChildRef ModelPartForEnumBase::GetChildRef(const std::string &, const HookFilter &, bool) { return ChildRef(); } - bool ModelPartForEnumBase::HasValue() const { return true; } - ModelPartType ModelPartForEnumBase::GetType() const { return type; } - const ModelPartType ModelPartForEnumBase::type = mpt_Simple; + void + ModelPartForEnumBase::OnEachChild(const ChildHandler &) + { + } + ChildRef + ModelPartForEnumBase::GetAnonChildRef(const HookFilter &) + { + return ChildRef(); + } + ChildRef + ModelPartForEnumBase::GetChildRef(const std::string &, const HookFilter &, bool) + { + return ChildRef(); + } + bool + ModelPartForEnumBase::HasValue() const + { + return true; + } + ModelPartType + ModelPartForEnumBase::GetType() const + { + return type; + } + const ModelPartType ModelPartForEnumBase::type = ModelPartType::Simple; - bool ModelPartForSequenceBase::HasValue() const { return true; } - ModelPartType ModelPartForSequenceBase::GetType() const { return type; } - const ModelPartType ModelPartForSequenceBase::type = mpt_Sequence; + bool + ModelPartForSequenceBase::HasValue() const + { + return true; + } + ModelPartType + ModelPartForSequenceBase::GetType() const + { + return type; + } + const ModelPartType ModelPartForSequenceBase::type = ModelPartType::Sequence; - bool ModelPartForDictionaryBase::HasValue() const { return true; } - ModelPartType ModelPartForDictionaryBase::GetType() const { return type; } - const ModelPartType ModelPartForDictionaryBase::type = mpt_Dictionary; + bool + ModelPartForDictionaryBase::HasValue() const + { + return true; + } + ModelPartType + ModelPartForDictionaryBase::GetType() const + { + return type; + } + const ModelPartType ModelPartForDictionaryBase::type = ModelPartType::Dictionary; // Streams // NOLINTNEXTLINE(hicpp-no-array-decay) - ChildRef ModelPartForStreamBase::GetAnonChildRef(const Slicer::HookFilter &) { throw InvalidStreamOperation(__FUNCTION__); } + ChildRef + ModelPartForStreamBase::GetAnonChildRef(const Slicer::HookFilter &) + { + throw InvalidStreamOperation(__FUNCTION__); + } // NOLINTNEXTLINE(hicpp-no-array-decay) - ChildRef ModelPartForStreamBase::GetChildRef(const std::string &, const Slicer::HookFilter &, bool) { throw InvalidStreamOperation(__FUNCTION__); } - ModelPartType ModelPartForStreamBase::GetType() const { return mpt_Sequence; } - bool ModelPartForStreamBase::HasValue() const { return true; } + ChildRef + ModelPartForStreamBase::GetChildRef(const std::string &, const Slicer::HookFilter &, bool) + { + throw InvalidStreamOperation(__FUNCTION__); + } + ModelPartType + ModelPartForStreamBase::GetType() const + { + return ModelPartType::Sequence; + } + bool + ModelPartForStreamBase::HasValue() const + { + return true; + } // Stream Roots ModelPartForStreamRootBase::ModelPartForStreamRootBase(const ModelPartPtr & mp) : ModelPartForRootBase(mp) { } // NOLINTNEXTLINE(hicpp-no-array-decay) - void ModelPartForStreamRootBase::Write(Ice::OutputStream&) const { throw InvalidStreamOperation(__FUNCTION__); } + void + ModelPartForStreamRootBase::Write(Ice::OutputStream &) const + { + throw InvalidStreamOperation(__FUNCTION__); + } // NOLINTNEXTLINE(hicpp-no-array-decay) - void ModelPartForStreamRootBase::Read(Ice::InputStream&) { throw InvalidStreamOperation(__FUNCTION__); } - bool ModelPartForStreamRootBase::HasValue() const { return mp->HasValue(); } - void ModelPartForStreamRootBase::OnEachChild(const ChildHandler & ch) { ch(GetRootName(), mp, NULL); } + void + ModelPartForStreamRootBase::Read(Ice::InputStream &) + { + throw InvalidStreamOperation(__FUNCTION__); + } + bool + ModelPartForStreamRootBase::HasValue() const + { + return mp->HasValue(); + } + void + ModelPartForStreamRootBase::OnEachChild(const ChildHandler & ch) + { + ch(GetRootName(), mp, NULL); + } } - diff --git a/slicer/slicer/modelPartsTypes.h b/slicer/slicer/modelPartsTypes.h index 99ccb81..b47353b 100644 --- a/slicer/slicer/modelPartsTypes.h +++ b/slicer/slicer/modelPartsTypes.h @@ -4,376 +4,367 @@ #include "modelParts.h" namespace Slicer { - template<typename T> - struct isLocal { + template<typename T> struct isLocal { static constexpr bool value = false; }; DLL_PUBLIC bool optionalCaseEq(const std::string & a, const std::string & b, bool matchCase); - template<typename T> - class DLL_PUBLIC ModelPartForRoot : public ModelPartForRootBase { - public: - ModelPartForRoot(T * o); + template<typename T> class DLL_PUBLIC ModelPartForRoot : public ModelPartForRootBase { + public: + explicit ModelPartForRoot(T * o); - const std::string & GetRootName() const override; - bool HasValue() const override; - void Write(::Ice::OutputStream &) const override; - void Read(::Ice::InputStream &) override; + const std::string & GetRootName() const override; + bool HasValue() const override; + void Write(::Ice::OutputStream &) const override; + void Read(::Ice::InputStream &) override; - static const std::string rootName; + static const std::string rootName; - private: - T * ModelObject; + private: + T * ModelObject; }; class DLL_PUBLIC ModelPartForSimpleBase : public ModelPart { - public: - void OnEachChild(const ChildHandler &) override; - ChildRef GetAnonChildRef(const HookFilter &) override; - ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; - bool HasValue() const override; - ModelPartType GetType() const override; - static const ModelPartType type; + public: + void OnEachChild(const ChildHandler &) override; + ChildRef GetAnonChildRef(const HookFilter &) override; + ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; + bool HasValue() const override; + ModelPartType GetType() const override; + static const ModelPartType type; }; template<typename T> class DLL_PUBLIC ModelPartForSimple : public ModelPartForSimpleBase, protected ModelPartModel<T> { - public: - using element_type = T; + public: + using element_type = T; - ModelPartForSimple(T * h); + explicit ModelPartForSimple(T * h); - void SetValue(ValueSource && s) override; - bool GetValue(ValueTarget && s) override; + void SetValue(ValueSource && s) override; + bool GetValue(ValueTarget && s) override; }; class DLL_PUBLIC ModelPartForConvertedBase : public ModelPart { - public: - void OnEachChild(const ChildHandler &) override; - ChildRef GetAnonChildRef(const HookFilter &) override; - ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; - bool HasValue() const override; - ModelPartType GetType() const override; - static const ModelPartType type; - - protected: - template<typename ET, typename MT, typename Conv> - inline static bool tryConvertFrom(ValueSource & vsp, MT * model, const Conv & conv); - template<typename ET, typename MT> - inline static bool tryConvertFrom(ValueSource & vsp, MT * model); - template<typename ET, typename MT, typename Conv> - inline static TryConvertResult tryConvertTo(ValueTarget & vsp, const MT * model, const Conv & conv); - template<typename ET, typename MT> - inline static TryConvertResult tryConvertTo(ValueTarget & vsp, const MT * model); + public: + void OnEachChild(const ChildHandler &) override; + ChildRef GetAnonChildRef(const HookFilter &) override; + ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; + bool HasValue() const override; + ModelPartType GetType() const override; + static const ModelPartType type; + + protected: + template<typename ET, typename MT, typename Conv> + inline static bool tryConvertFrom(ValueSource & vsp, MT * model, const Conv & conv); + template<typename ET, typename MT> inline static bool tryConvertFrom(ValueSource & vsp, MT * model); + template<typename ET, typename MT, typename Conv> + inline static TryConvertResult tryConvertTo(ValueTarget & vsp, const MT * model, const Conv & conv); + template<typename ET, typename MT> + inline static TryConvertResult tryConvertTo(ValueTarget & vsp, const MT * model); }; - template<typename T, typename M, T M::* MV> + template<typename T, typename M, T M::*MV> class DLL_PUBLIC ModelPartForConverted : public ModelPartForConvertedBase, protected ModelPartModel<T> { - public: - using element_type = T; + public: + using element_type = T; - ModelPartForConverted(T * h); + explicit ModelPartForConverted(T * h); - void SetValue(ValueSource && s) override; - bool GetValue(ValueTarget && s) override; + void SetValue(ValueSource && s) override; + bool GetValue(ValueTarget && s) override; }; - template<typename T, typename M, Ice::optional<T> M::* MV> - class DLL_PUBLIC ModelPartForConverted<Ice::optional<T>, M, MV> : public ModelPartForConvertedBase, protected ModelPartModel<Ice::optional<T>> { - public: - using element_type = Ice::optional<T>; + template<typename T, typename M, Ice::optional<T> M::*MV> + class DLL_PUBLIC ModelPartForConverted<Ice::optional<T>, M, MV> : + public ModelPartForConvertedBase, + protected ModelPartModel<Ice::optional<T>> { + public: + using element_type = Ice::optional<T>; - ModelPartForConverted(Ice::optional<T> * h); + explicit ModelPartForConverted(Ice::optional<T> * h); - void SetValue(ValueSource && s) override; - bool GetValue(ValueTarget && s) override; - bool HasValue() const override; + void SetValue(ValueSource && s) override; + bool GetValue(ValueTarget && s) override; + bool HasValue() const override; }; class DLL_PUBLIC ModelPartForOptionalBase : public ModelPart { - public: - void OnEachChild(const ChildHandler & ch) override; - void Complete() override; - ChildRef GetAnonChildRef(const HookFilter & flt) override; - ChildRef GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase = true) override; - void SetValue(ValueSource && s) override; - bool HasValue() const override; - bool IsOptional() const override; - const Metadata & GetMetadata() const override; - - protected: - virtual bool hasModel() const = 0; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - ModelPartPtr modelPart; + public: + void OnEachChild(const ChildHandler & ch) override; + void Complete() override; + ChildRef GetAnonChildRef(const HookFilter & flt) override; + ChildRef GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase = true) override; + void SetValue(ValueSource && s) override; + bool HasValue() const override; + bool IsOptional() const override; + const Metadata & GetMetadata() const override; + + protected: + virtual bool hasModel() const = 0; + ModelPartPtr modelPart; }; template<typename T> - class DLL_PUBLIC ModelPartForOptional : public ModelPartForOptionalBase, protected ModelPartModel<Ice::optional<typename T::element_type> > { - public: - ModelPartForOptional(Ice::optional< typename T::element_type > * h); - void Create() override; - bool GetValue(ValueTarget && s) override; - ModelPartType GetType() const override; - - protected: - bool hasModel() const override; + class DLL_PUBLIC ModelPartForOptional : + public ModelPartForOptionalBase, + protected ModelPartModel<Ice::optional<typename T::element_type>> { + public: + explicit ModelPartForOptional(Ice::optional<typename T::element_type> * h); + void Create() override; + bool GetValue(ValueTarget && s) override; + ModelPartType GetType() const override; + + protected: + bool hasModel() const override; }; class DLL_PUBLIC ModelPartForComplexBase : public ModelPart { - public: - ModelPartType GetType() const override; - static const ModelPartType type; + public: + ModelPartType GetType() const override; + static const ModelPartType type; - protected: - ModelPartPtr getSubclassModelPart(const std::string & name, void * m); + protected: + ModelPartPtr getSubclassModelPart(const std::string & name, void * m); - static void registerClass(const std::string & className, const std::string * typeName, const ClassRef &); - static void unregisterClass(const std::string & className, const std::string * typeName); - static TypeId GetTypeId(const std::string & id, const std::string & className); - static std::string demangle(const char * mangled); + static void registerClass(const std::string & className, const std::string * typeName, const ClassRef &); + static void unregisterClass(const std::string & className, const std::string * typeName); + static TypeId GetTypeId(const std::string & id, const std::string & className); + static std::string demangle(const char * mangled); - static const std::string & ToExchangeTypeName(const std::string &); - static const std::string & ToModelTypeName(const std::string &); + static const std::string & ToExchangeTypeName(const std::string &); + static const std::string & ToModelTypeName(const std::string &); }; - template<typename T> - class DLL_PUBLIC ModelPartForComplex : public ModelPartForComplexBase { - public: - class DLL_PRIVATE HookBase; - using HookPtr = std::unique_ptr<HookBase>; + template<typename T> class DLL_PUBLIC ModelPartForComplex : public ModelPartForComplexBase { + public: + class DLL_PRIVATE HookBase; + using HookPtr = std::unique_ptr<HookBase>; - template <typename MT, typename MP> - class DLL_PRIVATE Hook; + template<typename MT, typename MP> class DLL_PRIVATE Hook; - template <typename MT, typename MP> - class DLL_PRIVATE HookMetadata; + template<typename MT, typename MP> class DLL_PRIVATE HookMetadata; - void OnEachChild(const ChildHandler & ch) override; + void OnEachChild(const ChildHandler & ch) override; - ChildRef GetAnonChildRef(const HookFilter & flt) override; - ChildRef GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase = true) override; + ChildRef GetAnonChildRef(const HookFilter & flt) override; + ChildRef GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase = true) override; - const Metadata & GetMetadata() const override; + const Metadata & GetMetadata() const override; - virtual T * GetModel() = 0; + virtual T * GetModel() = 0; - protected: - template<typename R> - DLL_PRIVATE ChildRef GetChildRefFromRange(const R & range, const HookFilter & flt); + protected: + template<typename R> DLL_PRIVATE ChildRef GetChildRefFromRange(const R & range, const HookFilter & flt); - class DLL_PRIVATE Hooks; + class DLL_PRIVATE Hooks; - template<typename H, typename ... P> - static void addHook(Hooks &, const P & ...); + template<typename H, typename... P> static void addHook(Hooks &, const P &...); - static const Hooks hooks; - static const Metadata metadata; + static const Hooks hooks; + static const Metadata metadata; }; template<typename T> - class DLL_PUBLIC ModelPartForClass : public ModelPartForComplex<T>, protected ModelPartModel<std::shared_ptr<T> > { - public: - using element_type = std::shared_ptr<T>; + class DLL_PUBLIC ModelPartForClass : public ModelPartForComplex<T>, protected ModelPartModel<std::shared_ptr<T>> { + public: + using element_type = std::shared_ptr<T>; - ModelPartForClass(element_type * h); + explicit ModelPartForClass(element_type * h); - void Create() override; + void Create() override; - T * GetModel() override; + T * GetModel() override; - ModelPartPtr GetSubclassModelPart(const std::string & name) override; + ModelPartPtr GetSubclassModelPart(const std::string & name) override; - [[nodiscard]] bool HasValue() const override; + [[nodiscard]] bool HasValue() const override; - [[nodiscard]] TypeId GetTypeId() const override; - template<typename dummy = T> - const std::string & getTypeId(typename std::enable_if<std::is_base_of<Ice::Object, dummy>::value>::type * = nullptr) const; - template<typename dummy = T> - std::string getTypeId(typename std::enable_if<!std::is_base_of<Ice::Object, dummy>::value>::type * = nullptr) const; + [[nodiscard]] TypeId GetTypeId() const override; + template<typename dummy = T> + const std::string & getTypeId( + typename std::enable_if<std::is_base_of<Ice::Object, dummy>::value>::type * = nullptr) const; + template<typename dummy = T> + std::string getTypeId( + typename std::enable_if<!std::is_base_of<Ice::Object, dummy>::value>::type * = nullptr) const; - [[nodiscard]] Ice::optional<std::string> GetTypeIdProperty() const override; + [[nodiscard]] Ice::optional<std::string> GetTypeIdProperty() const override; - static const std::string typeIdProperty; - static const std::string * className; - static const std::string * typeName; + static const std::string typeIdProperty; + static const std::string * className; + static const std::string * typeName; - static ModelPartPtr CreateModelPart(void *); + static ModelPartPtr CreateModelPart(void *); - private: - static void initClassName(); - static void deleteClassName(); - static void registerClass() __attribute__ ((constructor(210))); - static void unregisterClass() __attribute__ ((destructor(210))); + private: + static void initClassName(); + static void deleteClassName(); + static void registerClass() __attribute__((constructor(210))); + static void unregisterClass() __attribute__((destructor(210))); }; template<typename T> class DLL_PUBLIC ModelPartForStruct : public ModelPartForComplex<T>, protected ModelPartModel<T> { - public: - using element_type = T; + public: + using element_type = T; - ModelPartForStruct(T * o); + explicit ModelPartForStruct(T * o); - T * GetModel() override; + T * GetModel() override; - [[nodiscard]] bool HasValue() const override; + [[nodiscard]] bool HasValue() const override; }; class DLL_PUBLIC ModelPartForEnumBase : public ModelPart { - public: - void OnEachChild(const ChildHandler &) override; - ChildRef GetAnonChildRef(const HookFilter &) override; - ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; - bool HasValue() const override; - ModelPartType GetType() const override; - static const ModelPartType type; + public: + void OnEachChild(const ChildHandler &) override; + ChildRef GetAnonChildRef(const HookFilter &) override; + ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; + bool HasValue() const override; + ModelPartType GetType() const override; + static const ModelPartType type; }; - template<typename T> - class DLL_PUBLIC ModelPartForEnum : public ModelPartForEnumBase, protected ModelPartModel<T> { - public: - using element_type = T; - class DLL_PRIVATE Enumerations; + template<typename T> class DLL_PUBLIC ModelPartForEnum : public ModelPartForEnumBase, protected ModelPartModel<T> { + public: + using element_type = T; + class DLL_PRIVATE Enumerations; - ModelPartForEnum(T * s); + explicit ModelPartForEnum(T * s); - const Metadata & GetMetadata() const override; + const Metadata & GetMetadata() const override; - void SetValue(ValueSource && s) override; + void SetValue(ValueSource && s) override; - bool GetValue(ValueTarget && s) override; + bool GetValue(ValueTarget && s) override; - static const Metadata metadata; - static const Enumerations enumerations; - DLL_PUBLIC static const std::string & lookup(T); - DLL_PUBLIC static T lookup(const std::string_view &); + static const Metadata metadata; + static const Enumerations enumerations; + DLL_PUBLIC static const std::string & lookup(T); + DLL_PUBLIC static T lookup(const std::string_view &); }; class DLL_PUBLIC ModelPartForSequenceBase : public ModelPart { - public: - bool HasValue() const override; - ModelPartType GetType() const override; - static const ModelPartType type; + public: + bool HasValue() const override; + ModelPartType GetType() const override; + static const ModelPartType type; }; template<typename T> class DLL_PUBLIC ModelPartForSequence : public ModelPartForSequenceBase, protected ModelPartModel<T> { - public: - using element_type = T; + public: + using element_type = T; - ModelPartForSequence(T * s); + explicit ModelPartForSequence(T * s); - void OnEachChild(const ChildHandler & ch) override; + void OnEachChild(const ChildHandler & ch) override; - ChildRef GetAnonChildRef(const HookFilter &) override; + ChildRef GetAnonChildRef(const HookFilter &) override; - ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; + ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; - const Metadata & GetMetadata() const override; + const Metadata & GetMetadata() const override; - ModelPartPtr GetContainedModelPart() override; + ModelPartPtr GetContainedModelPart() override; - static const Metadata metadata; - static const std::string elementName; + static const Metadata metadata; + static const std::string elementName; - private: - ModelPartPtr elementModelPart(typename T::value_type &) const; + private: + ModelPartPtr elementModelPart(typename T::value_type &) const; }; template<typename T> class DLL_PUBLIC ModelPartForDictionaryElementInserter : public ModelPartForStruct<typename T::value_type> { - public: - ModelPartForDictionaryElementInserter(T * d); + public: + explicit ModelPartForDictionaryElementInserter(T * d); - void Complete() override; + void Complete() override; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - typename T::value_type value; + typename T::value_type value; - private: - T * dictionary; + private: + T * dictionary; }; class DLL_PUBLIC ModelPartForDictionaryBase : public ModelPart { - public: - bool HasValue() const override; - ModelPartType GetType() const override; - static const ModelPartType type; + public: + bool HasValue() const override; + ModelPartType GetType() const override; + static const ModelPartType type; }; template<typename T> class DLL_PUBLIC ModelPartForDictionary : public ModelPartForDictionaryBase, protected ModelPartModel<T> { - public: - using element_type = T; + public: + using element_type = T; - ModelPartForDictionary(T * d); + explicit ModelPartForDictionary(T * d); - void OnEachChild(const ChildHandler & ch) override; + void OnEachChild(const ChildHandler & ch) override; - ChildRef GetAnonChildRef(const HookFilter &) override; + ChildRef GetAnonChildRef(const HookFilter &) override; - ChildRef GetChildRef(const std::string & name, const HookFilter &, bool matchCase = true) override; + ChildRef GetChildRef(const std::string & name, const HookFilter &, bool matchCase = true) override; - const Metadata & GetMetadata() const override; + const Metadata & GetMetadata() const override; - ModelPartPtr GetContainedModelPart() override; + ModelPartPtr GetContainedModelPart() override; - static const Metadata metadata; - static const std::string pairName; + static const Metadata metadata; + static const std::string pairName; }; - template<typename T> - class DLL_PUBLIC Stream { - public: - using Consumer = std::function<void(const T &)>; - using element_type = T; + template<typename T> class DLL_PUBLIC Stream { + public: + using Consumer = std::function<void(const T &)>; + using element_type = T; - virtual void Produce(const Consumer & c) = 0; + virtual void Produce(const Consumer & c) = 0; }; class DLL_PUBLIC ModelPartForStreamBase : public ModelPart { - public: - ModelPartType GetType() const override; - bool HasValue() const override; - ChildRef GetAnonChildRef(const HookFilter &) override; - ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; - - ModelPartPtr GetContainedModelPart() override = 0; - void OnEachChild(const ChildHandler & ch) override = 0; + public: + ModelPartType GetType() const override; + bool HasValue() const override; + ChildRef GetAnonChildRef(const HookFilter &) override; + ChildRef GetChildRef(const std::string &, const HookFilter &, bool matchCase = true) override; + + ModelPartPtr GetContainedModelPart() override = 0; + void OnEachChild(const ChildHandler & ch) override = 0; }; template<typename T> class DLL_PUBLIC ModelPartForStream : public ModelPartForStreamBase, ModelPartModel<Stream<T>> { - public: - ModelPartForStream(Stream<T> * s); + public: + explicit ModelPartForStream(Stream<T> * s); - ModelPartPtr GetContainedModelPart() override; - void OnEachChild(const ChildHandler & ch) override; + ModelPartPtr GetContainedModelPart() override; + void OnEachChild(const ChildHandler & ch) override; }; class DLL_PUBLIC ModelPartForStreamRootBase : public ModelPartForRootBase { - public: - ModelPartForStreamRootBase(const ModelPartPtr & mp); - - void Write(Ice::OutputStream&) const override; - void Read(Ice::InputStream&) override; - bool HasValue() const override; - void OnEachChild(const ChildHandler & ch) override; - const std::string & GetRootName() const override = 0; + public: + explicit ModelPartForStreamRootBase(const ModelPartPtr & mp); + + void Write(Ice::OutputStream &) const override; + void Read(Ice::InputStream &) override; + bool HasValue() const override; + void OnEachChild(const ChildHandler & ch) override; + const std::string & GetRootName() const override = 0; }; - template<typename T> - class DLL_PUBLIC ModelPartForStreamRoot : public ModelPartForStreamRootBase { - public: - ModelPartForStreamRoot(Stream<T> * s); + template<typename T> class DLL_PUBLIC ModelPartForStreamRoot : public ModelPartForStreamRootBase { + public: + explicit ModelPartForStreamRoot(Stream<T> * s); - const std::string & GetRootName() const override; + const std::string & GetRootName() const override; - private: - Stream<T> * stream; + private: + Stream<T> * stream; }; } #endif - - diff --git a/slicer/slicer/modelPartsTypes.impl.h b/slicer/slicer/modelPartsTypes.impl.h index 872304b..be464d1 100644 --- a/slicer/slicer/modelPartsTypes.impl.h +++ b/slicer/slicer/modelPartsTypes.impl.h @@ -1,67 +1,98 @@ #ifndef SLICER_MODELPARTSTYPES_IMPL_H #define SLICER_MODELPARTSTYPES_IMPL_H -#include "modelPartsTypes.h" #include "common.h" +#include "modelPartsTypes.h" #include <Ice/StreamHelpers.h> #include <IceUtil/Optional.h> -#include <boost/multi_index_container.hpp> -#include <boost/multi_index/sequenced_index.hpp> -#include <boost/multi_index/ordered_index.hpp> +#include <boost/algorithm/string/case_conv.hpp> #include <boost/multi_index/global_fun.hpp> #include <boost/multi_index/member.hpp> -#include <boost/algorithm/string/case_conv.hpp> +#include <boost/multi_index/ordered_index.hpp> +#include <boost/multi_index/sequenced_index.hpp> +#include <boost/multi_index_container.hpp> +#include <c++11Helpers.h> #ifdef __clang__ -#define FINALVISMODELPARTS DLL_PUBLIC +# define FINALVISMODELPARTS DLL_PUBLIC #else -#define FINALVISMODELPARTS +# define FINALVISMODELPARTS #endif #define CUSTOMMODELPARTFOR(Type, BaseModelPart, ModelPartType) \ - template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor<Type>() { return std::make_shared<ModelPartType>(nullptr); } \ - template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor(Type & s) { return std::make_shared<ModelPartType>(&s); } \ - template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor(const Type & s) { return CreateFor(const_cast<Type &>(s)); } \ - template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor(Ice::optional<Type> & s) { return std::make_shared<ModelPartForOptional<ModelPartType>>(&s); } \ - template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor(const Ice::optional<Type> & s) { return CreateFor(const_cast<Ice::optional<Type> &>(s)); } \ - template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(Type & s) { return std::make_shared<ModelPartForRoot<Type>>(&s); } \ - template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(Ice::optional<Type> & s) { return std::make_shared<ModelPartForRoot<Ice::optional<Type>>>(&s); } \ - template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(const Type & s) { return CreateRootFor(const_cast<Type &>(s)); } \ - template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(const Ice::optional<Type> & s) { return CreateRootFor(const_cast<Ice::optional<Type> &>(s)); } \ + template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor<Type>() \ + { \ + return std::make_shared<ModelPartType>(nullptr); \ + } \ + template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor(Type & s) \ + { \ + return std::make_shared<ModelPartType>(&s); \ + } \ + template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor(const Type & s) \ + { \ + return CreateFor(const_cast<Type &>(s)); \ + } \ + template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor(Ice::optional<Type> & s) \ + { \ + return std::make_shared<ModelPartForOptional<ModelPartType>>(&s); \ + } \ + template<> DLL_PUBLIC ModelPartPtr ModelPart::CreateFor(const Ice::optional<Type> & s) \ + { \ + return CreateFor(const_cast<Ice::optional<Type> &>(s)); \ + } \ + template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(Type & s) \ + { \ + return std::make_shared<ModelPartForRoot<Type>>(&s); \ + } \ + template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(Ice::optional<Type> & s) \ + { \ + return std::make_shared<ModelPartForRoot<Ice::optional<Type>>>(&s); \ + } \ + template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(const Type & s) \ + { \ + return CreateRootFor(const_cast<Type &>(s)); \ + } \ + template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(const Ice::optional<Type> & s) \ + { \ + return CreateRootFor(const_cast<Ice::optional<Type> &>(s)); \ + } \ template class FINALVISMODELPARTS BaseModelPart; \ template class ModelPartForRoot<Type>; \ - template class ModelPartForRoot< Ice::optional<Type> >; \ + template class ModelPartForRoot<Ice::optional<Type>>; -#define MODELPARTFOR(Type, ModelPartType) \ - CUSTOMMODELPARTFOR(Type, ModelPartType<Type>, ModelPartType<Type>) +#define MODELPARTFOR(Type, ModelPartType) CUSTOMMODELPARTFOR(Type, ModelPartType<Type>, ModelPartType<Type>) #define MODELPARTFORSTREAM(StreamImpl) \ namespace Slicer { \ - template<> DLL_PUBLIC ModelPartForRootPtr ModelPart::CreateRootFor(const StreamImpl & stream) { \ - return std::make_shared<ModelPartForStreamRoot<typename StreamImpl::element_type>>(const_cast<StreamImpl *>(&stream)); \ + template<> \ + DLL_PUBLIC ModelPartForRootPtr \ + ModelPart::CreateRootFor(const StreamImpl & stream) \ + { \ + return std::make_shared<ModelPartForStreamRoot<typename StreamImpl::element_type>>( \ + const_cast<StreamImpl *>(&stream)); \ } \ } #ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wundefined-var-template" +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wundefined-var-template" #endif namespace Slicer { // ModelPartForRoot template<typename T> - ModelPartForRoot<T>::ModelPartForRoot(T * o) : - ModelPartForRootBase(ModelPart::CreateFor(*o)), - ModelObject(o) + ModelPartForRoot<T>::ModelPartForRoot(T * o) : ModelPartForRootBase(ModelPart::CreateFor(*o)), ModelObject(o) { } template<typename T> - const std::string & ModelPartForRoot<T>::GetRootName() const + const std::string & + ModelPartForRoot<T>::GetRootName() const { return rootName; } template<typename T> - bool ModelPartForRoot<T>::HasValue() const + bool + ModelPartForRoot<T>::HasValue() const { return ModelObject && mp->HasValue(); } @@ -131,100 +162,144 @@ namespace Slicer { } template<typename T> - void ModelPartForRoot<T>::Write(::Ice::OutputStream & s) const + void + ModelPartForRoot<T>::Write(::Ice::OutputStream & s) const { typeWrite(s, *ModelObject); } template<typename T> - void ModelPartForRoot<T>::Read(::Ice::InputStream & s) + void + ModelPartForRoot<T>::Read(::Ice::InputStream & s) { typeRead(s, *ModelObject); } // ModelPartForSimple - template<typename T> - ModelPartForSimple<T>::ModelPartForSimple(T * h) : - ModelPartModel<T>(h) - { - } + template<typename T> ModelPartForSimple<T>::ModelPartForSimple(T * h) : ModelPartModel<T>(h) { } template<typename T> - void ModelPartForSimple<T>::SetValue(ValueSource && s) + void + ModelPartForSimple<T>::SetValue(ValueSource && s) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); s.set(*this->Model); } template<typename T> - bool ModelPartForSimple<T>::GetValue(ValueTarget && s) + bool + ModelPartForSimple<T>::GetValue(ValueTarget && s) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); s.get(*this->Model); return true; } // ModelPartForConverted - template<typename T, typename M, T M::* MV> - ModelPartForConverted<T, M, MV>::ModelPartForConverted(T * h) : - ModelPartModel<T>(h) + template<typename T, typename M, T M::*MV> + ModelPartForConverted<T, M, MV>::ModelPartForConverted(T * h) : ModelPartModel<T>(h) { } - template<typename T, typename M, Ice::optional<T> M::* MV> + template<typename T, typename M, Ice::optional<T> M::*MV> ModelPartForConverted<Ice::optional<T>, M, MV>::ModelPartForConverted(Ice::optional<T> * h) : ModelPartModel<Ice::optional<T>>(h) { } - template<typename T, typename M, Ice::optional<T> M::* MV> - bool ModelPartForConverted<Ice::optional<T>, M, MV>::HasValue() const + template<typename T, typename M, Ice::optional<T> M::*MV> + bool + ModelPartForConverted<Ice::optional<T>, M, MV>::HasValue() const { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); return (bool)*this->Model; } // Function traits helpers - template <typename R, typename ... Args> struct function_traits; - template <typename R, typename ... Args> struct function_traits<std::function<R(Args...)>> { + template<typename R, typename... Args> struct function_traits; + template<typename R, typename... Args> struct function_traits<std::function<R(Args...)>> { template<int A> struct arg { using type = typename std::tuple_element<A, std::tuple<Args...>>::type; }; }; - template <typename F> struct callable_traits : public function_traits<std::function<typename std::remove_pointer<F>::type>> { }; + template<typename F> + struct callable_traits : public function_traits<std::function<typename std::remove_pointer<F>::type>> { + }; // Converters that remove "optionalness". - template <typename X> - struct Coerce { + template<typename X> struct Coerce { using T = typename std::remove_const<typename std::remove_reference<X>::type>::type; - T & operator()(T & x) const { return x; } - const T & operator()(const T & x) const { return x; } - template <typename Y> - T & operator()(Ice::optional<Y> & x) const { if (!x) x = Y(); return *x; } - template <typename Y> - const T & operator()(const Ice::optional<Y> & x) const { return *x; } - static bool valueExists(const T &) { return true; } - static bool valueExists(const Ice::optional<T> & y) { return y.has_value(); } + T & + operator()(T & x) const + { + return x; + } + const T & + operator()(const T & x) const + { + return x; + } + template<typename Y> + T & + operator()(Ice::optional<Y> & x) const + { + if (!x) { + x = Y(); + } + return *x; + } + template<typename Y> + const T & + operator()(const Ice::optional<Y> & x) const + { + return *x; + } + static bool + valueExists(const T &) + { + return true; + } + static bool + valueExists(const Ice::optional<T> & y) + { + return y.has_value(); + } }; - template <typename X> - struct Coerce<Ice::optional<X>> { + template<typename X> struct Coerce<Ice::optional<X>> { using T = typename std::remove_const<typename std::remove_reference<X>::type>::type; - Ice::optional<T> & operator()(Ice::optional<T> & x) const { return x; } - const Ice::optional<T> & operator()(const Ice::optional<T> & x) const { return x; } - template <typename Y> - Ice::optional<T> operator()(Y & y) const { return y; } - static bool valueExists(const T &) { return true; } - static bool valueExists(const Ice::optional<T> &) { return true; } + Ice::optional<T> & + operator()(Ice::optional<T> & x) const + { + return x; + } + const Ice::optional<T> & + operator()(const Ice::optional<T> & x) const + { + return x; + } + template<typename Y> + Ice::optional<T> + operator()(Y & y) const + { + return y; + } + static bool + valueExists(const T &) + { + return true; + } + static bool + valueExists(const Ice::optional<T> &) + { + return true; + } }; template<typename ET, typename MT, typename Conv> - inline - bool ModelPartForConvertedBase::tryConvertFrom(ValueSource & vsp, MT * model, const Conv & conv) + inline bool + ModelPartForConvertedBase::tryConvertFrom(ValueSource & vsp, MT * model, const Conv & conv) { if (auto vspt = dynamic_cast<TValueSource<ET> *>(&vsp)) { using CA = typename callable_traits<Conv>::template arg<0>::type; @@ -240,8 +315,8 @@ namespace Slicer { } template<typename ET, typename MT> - inline - bool ModelPartForConvertedBase::tryConvertFrom(ValueSource & vsp, MT * model) + inline bool + ModelPartForConvertedBase::tryConvertFrom(ValueSource & vsp, MT * model) { if (auto vspt = dynamic_cast<TValueSource<ET> *>(&vsp)) { if (Coerce<ET>::valueExists(*model)) { @@ -253,8 +328,8 @@ namespace Slicer { } template<typename ET, typename MT, typename Conv> - inline - TryConvertResult ModelPartForConvertedBase::tryConvertTo(ValueTarget & vsp, const MT * model, const Conv & conv) + inline TryConvertResult + ModelPartForConvertedBase::tryConvertTo(ValueTarget & vsp, const MT * model, const Conv & conv) { if (auto vspt = dynamic_cast<TValueTarget<ET> *>(&vsp)) { using CA = typename callable_traits<Conv>::template arg<0>::type; @@ -263,32 +338,32 @@ namespace Slicer { auto converted = conv(Coerce<CA>()(*model)); if (Coerce<ET>::valueExists(converted)) { vspt->get(Coerce<ET>()(converted)); - return tcr_Value; + return TryConvertResult::Value; } } - return tcr_NoValue; + return TryConvertResult::NoValue; } - return tcr_NoAction; + return TryConvertResult::NoAction; } template<typename ET, typename MT> - inline - TryConvertResult ModelPartForConvertedBase::tryConvertTo(ValueTarget & vsp, const MT * model) + inline TryConvertResult + ModelPartForConvertedBase::tryConvertTo(ValueTarget & vsp, const MT * model) { if (auto vspt = dynamic_cast<TValueTarget<ET> *>(&vsp)) { if (Coerce<ET>::valueExists(*model)) { vspt->get(Coerce<ET>()(*model)); - return tcr_Value; + return TryConvertResult::Value; } - return tcr_NoValue; + return TryConvertResult::NoValue; } - return tcr_NoAction; + return TryConvertResult::NoAction; } // ModelPartForOptional template<typename T> - ModelPartForOptional<T>::ModelPartForOptional(Ice::optional< typename T::element_type > * h) : - ModelPartModel<Ice::optional< typename T::element_type> >(h) + ModelPartForOptional<T>::ModelPartForOptional(Ice::optional<typename T::element_type> * h) : + ModelPartModel<Ice::optional<typename T::element_type>>(h) { if (this->Model && *this->Model) { modelPart = std::make_shared<T>(&**this->Model); @@ -296,17 +371,17 @@ namespace Slicer { } template<typename T> - bool ModelPartForOptional<T>::hasModel() const + bool + ModelPartForOptional<T>::hasModel() const { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); return (bool)*this->Model; } template<typename T> - void ModelPartForOptional<T>::Create() + void + ModelPartForOptional<T>::Create() { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); if (!*this->Model) { *this->Model = typename T::element_type(); @@ -316,9 +391,9 @@ namespace Slicer { } template<typename T> - bool ModelPartForOptional<T>::GetValue(ValueTarget && s) + bool + ModelPartForOptional<T>::GetValue(ValueTarget && s) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); if (*this->Model) { return modelPart->GetValue(std::move(s)); @@ -327,34 +402,50 @@ namespace Slicer { } template<typename T> - ModelPartType ModelPartForOptional<T>::GetType() const + ModelPartType + ModelPartForOptional<T>::GetType() const { return T::type; } // ModelPartForComplex template<typename T> - class ModelPartForComplex<T>::Hooks : public boost::multi_index_container< - HookPtr, - boost::multi_index::indexed_by< - boost::multi_index::sequenced<>, - boost::multi_index::ordered_non_unique<boost::multi_index::member<HookCommon, const std::string, &HookCommon::name>, std::less<>>, - boost::multi_index::ordered_non_unique<boost::multi_index::member<HookCommon, const std::string, &HookCommon::name>, case_less>>> { + class ModelPartForComplex<T>::Hooks : + public boost::multi_index_container<HookPtr, + boost::multi_index::indexed_by<boost::multi_index::sequenced<>, + boost::multi_index::ordered_non_unique< + boost::multi_index::member<HookCommon, const std::string, &HookCommon::name>, + std::less<>>, + boost::multi_index::ordered_non_unique< + boost::multi_index::member<HookCommon, const std::string, &HookCommon::name>, + case_less>>> { }; template<typename T> - void ModelPartForComplex<T>::OnEachChild(const ChildHandler & ch) + void + ModelPartForComplex<T>::OnEachChild(const ChildHandler & ch) { for (const auto & h : hooks) { h->apply(ch, h->Get(GetModel())); } } - template<typename P> auto begin(const P & p) { return p.first; } - template<typename P> auto end(const P & p) { return p.second; } + template<typename P> + auto + begin(const P & p) + { + return p.first; + } + template<typename P> + auto + end(const P & p) + { + return p.second; + } template<typename T> template<typename R> - ChildRef ModelPartForComplex<T>::GetChildRefFromRange(const R & range, const HookFilter & flt) + ChildRef + ModelPartForComplex<T>::GetChildRefFromRange(const R & range, const HookFilter & flt) { auto model = GetModel(); for (const auto & h : range) { @@ -366,13 +457,15 @@ namespace Slicer { } template<typename T> - ChildRef ModelPartForComplex<T>::GetAnonChildRef(const HookFilter & flt) + ChildRef + ModelPartForComplex<T>::GetAnonChildRef(const HookFilter & flt) { return GetChildRefFromRange(hooks.template get<0>(), flt); } template<typename T> - ChildRef ModelPartForComplex<T>::GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase) + ChildRef + ModelPartForComplex<T>::GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase) { if (matchCase) { return GetChildRefFromRange(hooks.template get<1>().equal_range(name), flt); @@ -383,138 +476,137 @@ namespace Slicer { } template<typename T> - const Metadata & ModelPartForComplex<T>::GetMetadata() const + const Metadata & + ModelPartForComplex<T>::GetMetadata() const { return metadata; } template<typename T> - template<typename H, typename ... P> - void ModelPartForComplex<T>::addHook(Hooks & h, const P & ... p) + template<typename H, typename... P> + void + ModelPartForComplex<T>::addHook(Hooks & h, const P &... p) { h.push_back(std::make_unique<H>(p...)); } - template<typename T> - class DLL_PRIVATE ModelPartForComplex<T>::HookBase : public HookCommon { - public: - HookBase(const std::string & n) : - HookCommon(n) - { - } - virtual ~HookBase() = default; + template<typename T> class DLL_PRIVATE ModelPartForComplex<T>::HookBase : public HookCommon { + public: + explicit HookBase(const std::string & n) : HookCommon(n) { } + SPECIAL_MEMBERS_DEFAULT(HookBase); + virtual ~HookBase() = default; - virtual ModelPartPtr Get(T * t) const = 0; - const Metadata & GetMetadata() const override - { - return emptyMetadata; - } + virtual ModelPartPtr Get(T * t) const = 0; + [[nodiscard]] const Metadata & + GetMetadata() const override + { + return emptyMetadata; + } }; template<typename T> template<typename MT, typename MP> class DLL_PRIVATE ModelPartForComplex<T>::Hook : public ModelPartForComplex<T>::HookBase { - public: - Hook(MT T::* m, const std::string & n) : - HookBase(n), - member(m) - { - } - - ModelPartPtr Get(T * t) const override - { - return std::make_shared<MP>(t ? const_cast<typename std::remove_const<MT>::type *>(&(t->*member)) : NULL); - } + public: + Hook(MT T::*m, const std::string & n) : HookBase(n), member(m) { } + + ModelPartPtr + Get(T * t) const override + { + return std::make_shared<MP>( + t ? const_cast<typename std::remove_const<MT>::type *>(&(t->*member)) : nullptr); + } - private: - const MT T::* member; + private: + const MT T::*member; }; template<typename T> template<typename MT, typename MP> class DLL_PRIVATE ModelPartForComplex<T>::HookMetadata : public ModelPartForComplex<T>::template Hook<MT, MP> { - public: - HookMetadata(MT T::* member, const std::string & n, const Metadata & md) : - Hook<MT, MP>(member, n), - metadata(md) - { - } + public: + HookMetadata(MT T::*member, const std::string & n, Metadata md) : + Hook<MT, MP>(member, n), metadata(std::move(md)) + { + } - const Metadata & GetMetadata() const override - { - return metadata; - } + [[nodiscard]] const Metadata & + GetMetadata() const override + { + return metadata; + } - const Metadata metadata; + const Metadata metadata; }; // ModelPartForClass - template<typename T> - ModelPartForClass<T>::ModelPartForClass(element_type * h) : - ModelPartModel<element_type>(h) - { - } + template<typename T> ModelPartForClass<T>::ModelPartForClass(element_type * h) : ModelPartModel<element_type>(h) { } template<typename T> - void ModelPartForClass<T>::Create() + void + ModelPartForClass<T>::Create() { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); *this->Model = std::make_shared<T>(); } template<typename T> - T * ModelPartForClass<T>::GetModel() + T * + ModelPartForClass<T>::GetModel() { return this->Model ? this->Model->get() : nullptr; } template<typename T> - ModelPartPtr ModelPartForClass<T>::GetSubclassModelPart(const std::string & name) + ModelPartPtr + ModelPartForClass<T>::GetSubclassModelPart(const std::string & name) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); return ModelPartForComplexBase::getSubclassModelPart(name, this->Model); } template<typename T> - bool ModelPartForClass<T>::HasValue() const + bool + ModelPartForClass<T>::HasValue() const { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); return (bool)*this->Model; } template<typename T> - Ice::optional<std::string> ModelPartForClass<T>::GetTypeIdProperty() const + Ice::optional<std::string> + ModelPartForClass<T>::GetTypeIdProperty() const { return typeIdProperty; } template<typename T> - ModelPartPtr ModelPartForClass<T>::CreateModelPart(void * p) + ModelPartPtr + ModelPartForClass<T>::CreateModelPart(void * p) { return std::make_shared<ModelPartForClass<T>>(static_cast<element_type *>(p)); } template<typename T> - void ModelPartForClass<T>::deleteClassName() + void + ModelPartForClass<T>::deleteClassName() { delete className; delete typeName; } template<typename T> - void ModelPartForClass<T>::registerClass() + void + ModelPartForClass<T>::registerClass() { initClassName(); ModelPartForComplexBase::registerClass(*className, typeName, &ModelPartForClass<T>::CreateModelPart); } template<typename T> - void ModelPartForClass<T>::unregisterClass() + void + ModelPartForClass<T>::unregisterClass() { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(className); ModelPartForComplexBase::unregisterClass(*className, typeName); deleteClassName(); @@ -524,78 +616,72 @@ namespace Slicer { TypeId ModelPartForClass<T>::GetTypeId() const { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(className); return ModelPartForComplexBase::GetTypeId(getTypeId(), *className); } template<typename T> template<typename dummy> - const std::string & ModelPartForClass<T>::getTypeId(typename std::enable_if<std::is_base_of<Ice::Object, dummy>::value>::type *) const + const std::string & + ModelPartForClass<T>::getTypeId(typename std::enable_if<std::is_base_of<Ice::Object, dummy>::value>::type *) const { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); return (*this->Model)->ice_id(); } template<typename T> template<typename dummy> - std::string ModelPartForClass<T>::getTypeId(typename std::enable_if<!std::is_base_of<Ice::Object, dummy>::value>::type *) const + std::string + ModelPartForClass<T>::getTypeId(typename std::enable_if<!std::is_base_of<Ice::Object, dummy>::value>::type *) const { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); return ModelPartForComplexBase::demangle(typeid(*this->Model->get()).name()); } // ModelPartForStruct - template<typename T> - ModelPartForStruct<T>::ModelPartForStruct(T * o) : - ModelPartModel<T>(o) - { - } + template<typename T> ModelPartForStruct<T>::ModelPartForStruct(T * o) : ModelPartModel<T>(o) { } template<typename T> - T * ModelPartForStruct<T>::GetModel() + T * + ModelPartForStruct<T>::GetModel() { return this->Model; } template<typename T> - bool ModelPartForStruct<T>::HasValue() const + bool + ModelPartForStruct<T>::HasValue() const { return true; } // ModelPartForEnum - template<typename T> - using EnumPair = std::pair<T, std::string>; + template<typename T> using EnumPair = std::pair<T, std::string>; template<typename T> - class ModelPartForEnum<T>::Enumerations : public boost::multi_index_container< - EnumPair<T>, - boost::multi_index::indexed_by< - boost::multi_index::ordered_unique<boost::multi_index::member<EnumPair<T>, const T, &EnumPair<T>::first>>, - boost::multi_index::ordered_unique<boost::multi_index::member<EnumPair<T>, const std::string, &EnumPair<T>::second>, std::less<>> - >> { + class ModelPartForEnum<T>::Enumerations : + public boost::multi_index_container<EnumPair<T>, + boost::multi_index::indexed_by<boost::multi_index::ordered_unique<boost::multi_index::member< + EnumPair<T>, const T, &EnumPair<T>::first>>, + boost::multi_index::ordered_unique< + boost::multi_index::member<EnumPair<T>, const std::string, &EnumPair<T>::second>, + std::less<>>>> { }; - template<typename T> - ModelPartForEnum<T>::ModelPartForEnum(T * s) : - ModelPartModel<T>(s) - { - } + template<typename T> ModelPartForEnum<T>::ModelPartForEnum(T * s) : ModelPartModel<T>(s) { } template<typename T> - const Metadata & ModelPartForEnum<T>::GetMetadata() const + const Metadata & + ModelPartForEnum<T>::GetMetadata() const { return metadata; } template<int Side, typename Ex, typename ExP, typename T, typename V, typename R> - inline const auto & ModelPartForEnumLookup(const typename ModelPartForEnum<T>::Enumerations & enumerations, - const V & val, R EnumPair<T>::* rv) + inline const auto & + ModelPartForEnumLookup( + const typename ModelPartForEnum<T>::Enumerations & enumerations, const V & val, R EnumPair<T>::*rv) { const auto & side = enumerations.template get<Side>(); if (auto i = side.find(val); i != side.end()) { @@ -605,23 +691,25 @@ namespace Slicer { } template<typename T> - T ModelPartForEnum<T>::lookup(const std::string_view & val) + T + ModelPartForEnum<T>::lookup(const std::string_view & val) { - return ModelPartForEnumLookup<1, InvalidEnumerationSymbol, std::string, T>(enumerations, val, - &EnumPair<T>::first); + return ModelPartForEnumLookup<1, InvalidEnumerationSymbol, std::string, T>( + enumerations, val, &EnumPair<T>::first); } template<typename T> - const std::string & ModelPartForEnum<T>::lookup(T val) + const std::string & + ModelPartForEnum<T>::lookup(T val) { - return ModelPartForEnumLookup<0, InvalidEnumerationValue, ::Ice::Int, T>(enumerations, val, - &EnumPair<T>::second); + return ModelPartForEnumLookup<0, InvalidEnumerationValue, ::Ice::Int, T>( + enumerations, val, &EnumPair<T>::second); } template<typename T> - void ModelPartForEnum<T>::SetValue(ValueSource && s) + void + ModelPartForEnum<T>::SetValue(ValueSource && s) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); std::string val; s.set(val); @@ -629,54 +717,53 @@ namespace Slicer { } template<typename T> - bool ModelPartForEnum<T>::GetValue(ValueTarget && s) + bool + ModelPartForEnum<T>::GetValue(ValueTarget && s) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); s.get(lookup(*this->Model)); return true; } // ModelPartForSequence - template<typename T> - ModelPartForSequence<T>::ModelPartForSequence(T * s) : - ModelPartModel<T>(s) - { - } + template<typename T> ModelPartForSequence<T>::ModelPartForSequence(T * s) : ModelPartModel<T>(s) { } template<typename T> - void ModelPartForSequence<T>::OnEachChild(const ChildHandler & ch) + void + ModelPartForSequence<T>::OnEachChild(const ChildHandler & ch) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); - for(auto & element : *this->Model) { + for (auto & element : *this->Model) { ch(elementName, elementModelPart(element), NULL); } } template<typename T> - ChildRef ModelPartForSequence<T>::GetAnonChildRef(const HookFilter &) + ChildRef + ModelPartForSequence<T>::GetAnonChildRef(const HookFilter &) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); this->Model->push_back(typename element_type::value_type()); return ChildRef(ModelPart::CreateFor(this->Model->back())); } template<typename T> - const Metadata & ModelPartForSequence<T>::GetMetadata() const + const Metadata & + ModelPartForSequence<T>::GetMetadata() const { return metadata; } template<typename T> - ModelPartPtr ModelPartForSequence<T>::elementModelPart(typename T::value_type & e) const + ModelPartPtr + ModelPartForSequence<T>::elementModelPart(typename T::value_type & e) const { return ModelPart::CreateFor(e); } template<typename T> - ModelPartPtr ModelPartForSequence<T>::GetContainedModelPart() + ModelPartPtr + ModelPartForSequence<T>::GetContainedModelPart() { return ModelPart::CreateFor<typename T::value_type>(); } @@ -684,28 +771,24 @@ namespace Slicer { // ModelPartForDictionaryElementInserter template<typename T> ModelPartForDictionaryElementInserter<T>::ModelPartForDictionaryElementInserter(T * d) : - ModelPartForStruct<typename T::value_type>(&value), - dictionary(d) + ModelPartForStruct<typename T::value_type>(&value), dictionary(d) { } template<typename T> - void ModelPartForDictionaryElementInserter<T>::Complete() + void + ModelPartForDictionaryElementInserter<T>::Complete() { dictionary->insert(value); } // ModelPartForDictionary - template<typename T> - ModelPartForDictionary<T>::ModelPartForDictionary(T * d) : - ModelPartModel<T>(d) - { - } + template<typename T> ModelPartForDictionary<T>::ModelPartForDictionary(T * d) : ModelPartModel<T>(d) { } template<typename T> - void ModelPartForDictionary<T>::OnEachChild(const ChildHandler & ch) + void + ModelPartForDictionary<T>::OnEachChild(const ChildHandler & ch) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); for (auto & pair : *this->Model) { ch(pairName, std::make_shared<ModelPartForStruct<typename T::value_type>>(&pair), NULL); @@ -713,17 +796,17 @@ namespace Slicer { } template<typename T> - ChildRef ModelPartForDictionary<T>::GetAnonChildRef(const HookFilter &) + ChildRef + ModelPartForDictionary<T>::GetAnonChildRef(const HookFilter &) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); return ChildRef(std::make_shared<ModelPartForDictionaryElementInserter<T>>(this->Model)); } template<typename T> - ChildRef ModelPartForDictionary<T>::GetChildRef(const std::string & name, const HookFilter &, bool matchCase) + ChildRef + ModelPartForDictionary<T>::GetChildRef(const std::string & name, const HookFilter &, bool matchCase) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); if (!optionalCaseEq(name, pairName, matchCase)) { throw IncorrectElementName(name); @@ -732,23 +815,21 @@ namespace Slicer { } template<typename T> - const Metadata & ModelPartForDictionary<T>::GetMetadata() const + const Metadata & + ModelPartForDictionary<T>::GetMetadata() const { return metadata; } template<typename T> - ModelPartPtr ModelPartForDictionary<T>::GetContainedModelPart() + ModelPartPtr + ModelPartForDictionary<T>::GetContainedModelPart() { return std::make_shared<ModelPartForStruct<typename T::value_type>>(nullptr); } // ModelPartForStream - template<typename T> - ModelPartForStream<T>::ModelPartForStream(Stream<T> * s) : - ModelPartModel<Stream<T>>(s) - { - } + template<typename T> ModelPartForStream<T>::ModelPartForStream(Stream<T> * s) : ModelPartModel<Stream<T>>(s) { } template<typename T> ModelPartPtr @@ -761,7 +842,6 @@ namespace Slicer { void ModelPartForStream<T>::OnEachChild(const ChildHandler & ch) { - // NOLINTNEXTLINE(hicpp-no-array-decay,-warnings-as-errors) BOOST_ASSERT(this->Model); this->Model->Produce([&ch](const T & element) { ch(ModelPartForSequence<std::vector<T>>::elementName, ModelPart::CreateFor(element), NULL); @@ -782,8 +862,7 @@ namespace Slicer { } } #ifdef __clang__ -#pragma clang diagnostic pop +# pragma clang diagnostic pop #endif #endif - diff --git a/slicer/slicer/serializer.cpp b/slicer/slicer/serializer.cpp index ad64fd9..329ef86 100644 --- a/slicer/slicer/serializer.cpp +++ b/slicer/slicer/serializer.cpp @@ -5,4 +5,3 @@ INSTANTIATEFACTORY(Slicer::Serializer, std::ostream &); INSTANTIATEFACTORY(Slicer::Deserializer, std::istream &); INSTANTIATEFACTORY(Slicer::Serializer, const std::filesystem::path &); INSTANTIATEFACTORY(Slicer::Deserializer, const std::filesystem::path &); - diff --git a/slicer/slicer/serializer.h b/slicer/slicer/serializer.h index 90acc18..75df79a 100644 --- a/slicer/slicer/serializer.h +++ b/slicer/slicer/serializer.h @@ -1,32 +1,32 @@ #ifndef SLICER_SERIALIZER_H #define SLICER_SERIALIZER_H +#include <c++11Helpers.h> +#include <factory.h> #include <filesystem> #include <slicer/modelParts.h> #include <visibility.h> -#include <factory.h> -#include <c++11Helpers.h> namespace Slicer { class DLL_PUBLIC Serializer { - public: - Serializer() = default; - SPECIAL_MEMBERS_DEFAULT(Serializer); + public: + Serializer() = default; + SPECIAL_MEMBERS_DEFAULT(Serializer); - virtual ~Serializer() = default; + virtual ~Serializer() = default; - virtual void Serialize(ModelPartForRootPtr) = 0; + virtual void Serialize(ModelPartForRootPtr) = 0; }; using SerializerPtr = std::shared_ptr<Serializer>; class DLL_PUBLIC Deserializer { - public: - Deserializer() = default; - SPECIAL_MEMBERS_DEFAULT(Deserializer); + public: + Deserializer() = default; + SPECIAL_MEMBERS_DEFAULT(Deserializer); - virtual ~Deserializer() = default; + virtual ~Deserializer() = default; - virtual void Deserialize(ModelPartForRootPtr) = 0; + virtual void Deserialize(ModelPartForRootPtr) = 0; }; using DeserializerPtr = std::shared_ptr<Deserializer>; @@ -37,4 +37,3 @@ namespace Slicer { } #endif - diff --git a/slicer/slicer/slicer.cpp b/slicer/slicer/slicer.cpp index 512e025..af55977 100644 --- a/slicer/slicer/slicer.cpp +++ b/slicer/slicer/slicer.cpp @@ -3,23 +3,11 @@ #include <compileTimeFormatter.h> namespace Slicer { - Slicer::ChildRef::ChildRef() : - mpp(), - mdr(emptyMetadata) - { - } + Slicer::ChildRef::ChildRef() : mpp(), mdr(emptyMetadata) { } - Slicer::ChildRef::ChildRef(ModelPartPtr m) : - mpp(std::move(m)), - mdr(emptyMetadata) - { - } + Slicer::ChildRef::ChildRef(ModelPartPtr m) : mpp(std::move(m)), mdr(emptyMetadata) { } - Slicer::ChildRef::ChildRef(Slicer::ModelPartPtr mp, const Slicer::Metadata & md) : - mpp(std::move(mp)), - mdr(md) - { - } + Slicer::ChildRef::ChildRef(Slicer::ModelPartPtr mp, const Slicer::Metadata & md) : mpp(std::move(mp)), mdr(md) { } ModelPartPtr Slicer::ChildRef::Child() const @@ -117,4 +105,3 @@ namespace Slicer { InvalidStreamOperationMsg::write(s, method); } } - diff --git a/slicer/slicer/slicer.h b/slicer/slicer/slicer.h index 16d5a46..dcab8b3 100644 --- a/slicer/slicer/slicer.h +++ b/slicer/slicer/slicer.h @@ -5,36 +5,35 @@ #include <slicer/serializer.h> namespace Slicer { - template <typename Object> + template<typename Object> Object DeserializeAnyWith(const DeserializerPtr & deserializer) { - Object object; + Object object {}; deserializer->Deserialize(ModelPart::CreateRootFor<Object>(object)); return object; } - template <typename Deserializer, typename Object, typename ... SerializerParams> + template<typename Deserializer, typename Object, typename... SerializerParams> Object - DeserializeAny(SerializerParams && ... sp) + DeserializeAny(SerializerParams &&... sp) { - return DeserializeAnyWith<Object>(std::make_shared<Deserializer>(sp ...)); + return DeserializeAnyWith<Object>(std::make_shared<Deserializer>(sp...)); } - template <typename Object> + template<typename Object> void SerializeAnyWith(const Object & object, const SerializerPtr & serializer) { serializer->Serialize(ModelPart::CreateRootFor<const Object>(object)); } - template <typename Serializer, typename Object, typename ... SerializerParams> + template<typename Serializer, typename Object, typename... SerializerParams> void - SerializeAny(const Object & object, SerializerParams && ... sp) + SerializeAny(const Object & object, SerializerParams &&... sp) { - SerializeAnyWith(object, std::make_shared<Serializer>(sp ...)); + SerializeAnyWith(object, std::make_shared<Serializer>(sp...)); } } #endif - diff --git a/slicer/test/compilation.cpp b/slicer/test/compilation.cpp index 0475bbe..2ed73e4 100644 --- a/slicer/test/compilation.cpp +++ b/slicer/test/compilation.cpp @@ -1,20 +1,21 @@ #define BOOST_TEST_MODULE compilation #include <boost/test/unit_test.hpp> -#include <types.h> #include <locals.h> #include <slicer/modelParts.h> #include <slicer/modelPartsTypes.h> +#include <types.h> // LCOV_EXCL_START BOOST_TEST_DONT_PRINT_LOG_VALUE(std::type_info); +BOOST_TEST_DONT_PRINT_LOG_VALUE(Slicer::ModelPartType); // LCOV_EXCL_STOP #define TypeTest(Var, Expr, Explicit, Expected) \ Var obj = Expr; \ Slicer::ModelPartPtr mpp = Slicer::ModelPart::CreateFor(obj); \ BOOST_REQUIRE_EQUAL(Slicer::Expected, mpp->GetType()); \ - \ +\ BOOST_TEST_CONTEXT(#Var) { \ auto mppvalue = mpp.get(); \ auto amppvalue = mpp.get(); \ @@ -24,18 +25,18 @@ BOOST_TEST_DONT_PRINT_LOG_VALUE(std::type_info); BOOST_REQUIRE_EQUAL(typeid(*mppvalue), typeid(*apmppvalue)); \ } -#define StackTypeTest(Var, Explicit, Expected) \ - TypeTest(Var, Var(), Explicit, Expected) +#define StackTypeTest(Var, Explicit, Expected) TypeTest(Var, Var(), Explicit, Expected) -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_class ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_class) { - TypeTest(TestModule::BuiltInsPtr, std::make_shared<TestModule::BuiltIns>(), ModelPartForClass, mpt_Complex); + TypeTest(TestModule::BuiltInsPtr, std::make_shared<TestModule::BuiltIns>(), ModelPartForClass, + ModelPartType::Complex); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -static -void -hookHandler(std::vector<std::string> * names, const std::string & name, const Slicer::ModelPartPtr & mpp, const Slicer::HookCommon * h) +static void +hookHandler(std::vector<std::string> * names, const std::string & name, const Slicer::ModelPartPtr & mpp, + const Slicer::HookCommon * h) { names->push_back(name); BOOST_REQUIRE(mpp); @@ -44,107 +45,110 @@ hookHandler(std::vector<std::string> * names, const std::string & name, const Sl BOOST_REQUIRE_EQUAL(h->name, name); } - -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_sequenceclasses ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_sequenceclasses) { - StackTypeTest(TestModule::Classes, ModelPartForSequence, mpt_Sequence); + StackTypeTest(TestModule::Classes, ModelPartForSequence, ModelPartType::Sequence); auto cmpp = mpp->GetContainedModelPart(); BOOST_REQUIRE(cmpp); - BOOST_REQUIRE_EQUAL(Slicer::mpt_Complex, cmpp->GetType()); + BOOST_REQUIRE_EQUAL(Slicer::ModelPartType::Complex, cmpp->GetType()); std::vector<std::string> names; - cmpp->OnEachChild(std::bind(&hookHandler, &names, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); + cmpp->OnEachChild([&](auto && PH1, auto && PH2, auto && PH3) { + hookHandler(&names, PH1, PH2, PH3); + }); BOOST_REQUIRE_EQUAL(2, names.size()); BOOST_REQUIRE_EQUAL("a", names.front()); BOOST_REQUIRE_EQUAL("b", names.back()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_sequencestructs ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_sequencestructs) { - StackTypeTest(TestModule::Structs, ModelPartForSequence, mpt_Sequence); + StackTypeTest(TestModule::Structs, ModelPartForSequence, ModelPartType::Sequence); auto cmpp = mpp->GetContainedModelPart(); BOOST_REQUIRE(cmpp); - BOOST_REQUIRE_EQUAL(Slicer::mpt_Complex, cmpp->GetType()); + BOOST_REQUIRE_EQUAL(Slicer::ModelPartType::Complex, cmpp->GetType()); std::vector<std::string> names; - cmpp->OnEachChild(std::bind(&hookHandler, &names, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); + cmpp->OnEachChild([&](auto && PH1, auto && PH2, auto && PH3) { + hookHandler(&names, PH1, PH2, PH3); + }); BOOST_REQUIRE_EQUAL(2, names.size()); BOOST_REQUIRE_EQUAL("a", names.front()); BOOST_REQUIRE_EQUAL("b", names.back()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_mapclasses ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_mapclasses) { - StackTypeTest(TestModule::ClassMap, ModelPartForDictionary, mpt_Dictionary); + StackTypeTest(TestModule::ClassMap, ModelPartForDictionary, ModelPartType::Dictionary); auto cmpp = mpp->GetContainedModelPart(); BOOST_REQUIRE(cmpp); - BOOST_REQUIRE_EQUAL(Slicer::mpt_Complex, cmpp->GetType()); + BOOST_REQUIRE_EQUAL(Slicer::ModelPartType::Complex, cmpp->GetType()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_mapstructs ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_mapstructs) { - StackTypeTest(TestModule::StructMap, ModelPartForDictionary, mpt_Dictionary); + StackTypeTest(TestModule::StructMap, ModelPartForDictionary, ModelPartType::Dictionary); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_bi_string ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_bi_string) { - StackTypeTest(std::string, ModelPartForSimple, mpt_Simple); + StackTypeTest(std::string, ModelPartForSimple, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_bi_bool ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_bi_bool) { - StackTypeTest(bool, ModelPartForSimple, mpt_Simple); + StackTypeTest(bool, ModelPartForSimple, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_bi_float ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_bi_float) { - StackTypeTest(Ice::Float, ModelPartForSimple, mpt_Simple); + StackTypeTest(Ice::Float, ModelPartForSimple, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_bi_double ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_bi_double) { - StackTypeTest(Ice::Double, ModelPartForSimple, mpt_Simple); + StackTypeTest(Ice::Double, ModelPartForSimple, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_bi_byte ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_bi_byte) { - StackTypeTest(Ice::Byte, ModelPartForSimple, mpt_Simple); + StackTypeTest(Ice::Byte, ModelPartForSimple, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_bi_short ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_bi_short) { - StackTypeTest(Ice::Short, ModelPartForSimple, mpt_Simple); + StackTypeTest(Ice::Short, ModelPartForSimple, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_bi_int ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_bi_int) { - StackTypeTest(Ice::Int, ModelPartForSimple, mpt_Simple); + StackTypeTest(Ice::Int, ModelPartForSimple, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_bi_long ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_bi_long) { - StackTypeTest(Ice::Long, ModelPartForSimple, mpt_Simple); + StackTypeTest(Ice::Long, ModelPartForSimple, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_struct ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_struct) { - StackTypeTest(TestModule::StructType, ModelPartForStruct, mpt_Complex); + StackTypeTest(TestModule::StructType, ModelPartForStruct, ModelPartType::Complex); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( compile_auto_modelpart_type_enum ) +BOOST_AUTO_TEST_CASE(compile_auto_modelpart_type_enum) { - StackTypeTest(TestModule::SomeNumbers, ModelPartForEnum, mpt_Simple); + StackTypeTest(TestModule::SomeNumbers, ModelPartForEnum, ModelPartType::Simple); BOOST_REQUIRE_EQUAL(mpp.get(), mpp->GetContainedModelPart().get()); } -BOOST_AUTO_TEST_CASE( normalClassTypeId ) +BOOST_AUTO_TEST_CASE(normalClassTypeId) { TestModule::BasePtr base = std::make_shared<TestModule::Base>(1); BOOST_REQUIRE(base); @@ -154,7 +158,7 @@ BOOST_AUTO_TEST_CASE( normalClassTypeId ) BOOST_REQUIRE(!baseType); } -BOOST_AUTO_TEST_CASE( normalSubClassTypeId ) +BOOST_AUTO_TEST_CASE(normalSubClassTypeId) { TestModule::BasePtr base = std::make_shared<TestModule::D1>(1, 2); BOOST_REQUIRE(base); @@ -165,7 +169,7 @@ BOOST_AUTO_TEST_CASE( normalSubClassTypeId ) BOOST_REQUIRE_EQUAL(*baseType, "::TestModule::D1"); } -BOOST_AUTO_TEST_CASE( normalSubSubClassTypeId ) +BOOST_AUTO_TEST_CASE(normalSubSubClassTypeId) { TestModule::BasePtr base = std::make_shared<TestModule::D3>(1, 2, 3); BOOST_REQUIRE(base); @@ -176,7 +180,7 @@ BOOST_AUTO_TEST_CASE( normalSubSubClassTypeId ) BOOST_REQUIRE_EQUAL(*baseType, "::TestModule::D3"); } -BOOST_AUTO_TEST_CASE( localClassTypeId ) +BOOST_AUTO_TEST_CASE(localClassTypeId) { Locals::LocalClassPtr base = std::make_shared<Locals::LocalClass>(1, "One"); BOOST_REQUIRE(base); @@ -186,7 +190,7 @@ BOOST_AUTO_TEST_CASE( localClassTypeId ) BOOST_REQUIRE(!baseType); } -BOOST_AUTO_TEST_CASE( localSubClassTypeId ) +BOOST_AUTO_TEST_CASE(localSubClassTypeId) { Locals::LocalClassPtr base = std::make_shared<Locals::LocalSubClass>(1, "One", 3.1); BOOST_REQUIRE(base); @@ -197,7 +201,7 @@ BOOST_AUTO_TEST_CASE( localSubClassTypeId ) BOOST_REQUIRE_EQUAL(*baseType, "::Locals::LocalSubClass"); } -BOOST_AUTO_TEST_CASE( localSubSubClassTypeId ) +BOOST_AUTO_TEST_CASE(localSubSubClassTypeId) { Locals::LocalClassPtr base = std::make_shared<Locals::LocalSub2Class>(1, "One", 3.1, 1); BOOST_REQUIRE(base); @@ -207,4 +211,3 @@ BOOST_AUTO_TEST_CASE( localSubSubClassTypeId ) BOOST_REQUIRE(baseType); BOOST_REQUIRE_EQUAL(*baseType, "::Locals::LocalSub2Class"); } - diff --git a/slicer/test/conversions.cpp b/slicer/test/conversions.cpp index 9c148aa..8af0f0f 100644 --- a/slicer/test/conversions.cpp +++ b/slicer/test/conversions.cpp @@ -1,7 +1,7 @@ #include "conversions.h" #include <boost/numeric/conversion/cast.hpp> -#define SHORT(x) boost::numeric_cast< ::Ice::Short , int64_t >(x) +#define SHORT(x) boost::numeric_cast<::Ice::Short, int64_t>(x) namespace Slicer { DLL_PUBLIC @@ -16,17 +16,16 @@ namespace Slicer { ::TestModule::DateTime ptimeToDateTime(const boost::posix_time::ptime & pt) { - return ::TestModule::DateTime({ - SHORT(pt.date().year()), SHORT(pt.date().month()), SHORT(pt.date().day()), - SHORT(pt.time_of_day().hours()), SHORT(pt.time_of_day().minutes()), SHORT(pt.time_of_day().seconds()) - }); + return ::TestModule::DateTime({SHORT(pt.date().year()), SHORT(pt.date().month()), SHORT(pt.date().day()), + SHORT(pt.time_of_day().hours()), SHORT(pt.time_of_day().minutes()), SHORT(pt.time_of_day().seconds())}); } DLL_PUBLIC std::string isoDateToString(const ::TestModule::IsoDate & in) { - struct tm tm {}; + struct tm tm { + }; tm.tm_mday = in.day; tm.tm_mon = in.month - 1; tm.tm_year = in.year - 1900; @@ -41,27 +40,28 @@ namespace Slicer { ::TestModule::IsoDate stringToIsoDate(const std::string & in) { - struct tm tm {}; + struct tm tm { + }; auto end = strptime(in.c_str(), "%Y-%m-%d", &tm); if (!end || *end) { // LCOV_EXCL_START throw std::runtime_error("Invalid iso-date string: " + in); // LCOV_EXCL_STOP } - return ::TestModule::IsoDate({ - SHORT(tm.tm_year + 1900), SHORT(tm.tm_mon + 1), SHORT(tm.tm_mday)}); + return ::TestModule::IsoDate({SHORT(tm.tm_year + 1900), SHORT(tm.tm_mon + 1), SHORT(tm.tm_mday)}); } DLL_PUBLIC std::string dateTimeToString(const ::TestModule::DateTime & in) { - struct tm tm {}; + struct tm tm { + }; tm.tm_sec = in.second; tm.tm_min = in.minute; tm.tm_hour = in.hour; tm.tm_mday = in.day; - tm.tm_mon = in.month- 1; + tm.tm_mon = in.month - 1; tm.tm_year = in.year - 1900; tm.tm_isdst = -1; mktime(&tm); @@ -75,15 +75,15 @@ namespace Slicer { ::TestModule::DateTime stringToDateTime(const std::string & in) { - struct tm tm {}; + struct tm tm { + }; auto end = strptime(in.c_str(), "%Y-%b-%d %H:%M:%S", &tm); if (!end || *end) { // LCOV_EXCL_START throw std::runtime_error("Invalid date string: " + in); // LCOV_EXCL_STOP } - return ::TestModule::DateTime({ - SHORT(tm.tm_year + 1900), SHORT(tm.tm_mon + 1), SHORT(tm.tm_mday), + return ::TestModule::DateTime({SHORT(tm.tm_year + 1900), SHORT(tm.tm_mon + 1), SHORT(tm.tm_mday), SHORT(tm.tm_hour), SHORT(tm.tm_min), SHORT(tm.tm_sec)}); } @@ -111,10 +111,7 @@ namespace Slicer { namespace TestModule { int completions = 0; - AbValidator::AbValidator(ClassTypePtr * m) : - Slicer::ModelPartForClass<ClassType>(m) - { - } + AbValidator::AbValidator(ClassTypePtr * m) : Slicer::ModelPartForClass<ClassType>(m) { } void AbValidator::Complete() @@ -129,10 +126,7 @@ namespace TestModule { completions += 1; } - MonthValidator::MonthValidator(::Ice::Short * m) : - Slicer::ModelPartForSimple<::Ice::Short>(m) - { - } + MonthValidator::MonthValidator(::Ice::Short * m) : Slicer::ModelPartForSimple<::Ice::Short>(m) { } void MonthValidator::Complete() @@ -147,4 +141,3 @@ namespace TestModule { completions += 1; } } - diff --git a/slicer/test/conversions.h b/slicer/test/conversions.h index bf70407..dfb18d6 100644 --- a/slicer/test/conversions.h +++ b/slicer/test/conversions.h @@ -2,41 +2,36 @@ #define SLICER_TEST_CONVERSIONS_H #include <boost/date_time/posix_time/posix_time_types.hpp> -#include <visibility.h> #include <slicer/modelPartsTypes.h> #include <types.h> +#include <visibility.h> namespace TestModule { DLL_PUBLIC extern int completions; class DLL_PUBLIC AbValidator : public Slicer::ModelPartForClass<ClassType> { - public: - explicit AbValidator(ClassTypePtr *); + public: + explicit AbValidator(ClassTypePtr *); - void Complete() override; + void Complete() override; }; class DLL_PUBLIC MonthValidator : public Slicer::ModelPartForSimple<::Ice::Short> { - public: - explicit MonthValidator(::Ice::Short *); + public: + explicit MonthValidator(::Ice::Short *); - void Complete() override; + void Complete() override; }; } namespace Slicer { DLL_PUBLIC - ::TestModule::DateTime - stringToDateTime(const std::string & in); + ::TestModule::DateTime stringToDateTime(const std::string & in); DLL_PUBLIC - std::string - dateTimeToString(const ::TestModule::DateTime & in); + std::string dateTimeToString(const ::TestModule::DateTime & in); DLL_PUBLIC - Ice::optional<Ice::Int> - str2int(const std::string &); + Ice::optional<Ice::Int> str2int(const std::string &); DLL_PUBLIC - std::string - int2str(const Ice::optional<Ice::Int> &); + std::string int2str(const Ice::optional<Ice::Int> &); } #endif - diff --git a/slicer/test/helpers.cpp b/slicer/test/helpers.cpp index cbc6623..808e9d0 100644 --- a/slicer/test/helpers.cpp +++ b/slicer/test/helpers.cpp @@ -1,6 +1,6 @@ #include "helpers.h" -#include <fstream> #include <boost/test/test_tools.hpp> +#include <fstream> void diff(const std::filesystem::path & left, const std::filesystem::path & right) @@ -9,9 +9,12 @@ diff(const std::filesystem::path & left, const std::filesystem::path & right) std::ifstream fr(right.string()); std::string l, r; - std::copy_if(std::istreambuf_iterator<char>(fl), std::istreambuf_iterator<char>(), back_inserter(l), [](char x){ return !isspace(x); }); - std::copy_if(std::istreambuf_iterator<char>(fr), std::istreambuf_iterator<char>(), back_inserter(r), [](char x){ return !isspace(x); }); + std::copy_if(std::istreambuf_iterator<char>(fl), std::istreambuf_iterator<char>(), back_inserter(l), [](char x) { + return !isspace(x); + }); + std::copy_if(std::istreambuf_iterator<char>(fr), std::istreambuf_iterator<char>(), back_inserter(r), [](char x) { + return !isspace(x); + }); BOOST_REQUIRE_EQUAL(l, r); } - diff --git a/slicer/test/helpers.h b/slicer/test/helpers.h index 47754a9..b5db1bf 100644 --- a/slicer/test/helpers.h +++ b/slicer/test/helpers.h @@ -1,14 +1,12 @@ #ifndef SLICER_TEST_HELPERS_H #define SLICER_TEST_HELPERS_H +#include <filesystem> #include <string> #include <visibility.h> -#include <filesystem> // These are just thin wrappers that throw exceptions DLL_PUBLIC -void -diff(const std::filesystem::path & left, const std::filesystem::path & right); +void diff(const std::filesystem::path & left, const std::filesystem::path & right); #endif - diff --git a/slicer/test/preprocessor.cpp b/slicer/test/preprocessor.cpp index fe789d0..454d58a 100644 --- a/slicer/test/preprocessor.cpp +++ b/slicer/test/preprocessor.cpp @@ -1,34 +1,23 @@ #define BOOST_TEST_MODULE preprocess #include <boost/test/unit_test.hpp> -#include <tool/parser.h> -#include <common.h> +#include "helpers.h" #include <boost/format.hpp> #include <buffer.h> +#include <common.h> #include <definedDirs.h> -#include "helpers.h" +#include <tool/parser.h> using ComponentsCount = std::map<std::string, unsigned int>; -ComponentsCount COMPONENTS_IN_TEST_ICE = { - { "classtype.ice", 1 }, - { "classes.ice", 3 }, - { "collections.ice", 6 }, - { "enums.ice", 2 }, - { "inheritance.ice", 12 }, - { "interfaces.ice", 0 }, - { "json.ice", 2 }, - { "locals.ice", 7 }, - { "optionals.ice", 2 }, - { "structs.ice", 4 }, - { "types.ice", 3 }, - { "xml.ice", 5 } -}; +ComponentsCount COMPONENTS_IN_TEST_ICE = {{"classtype.ice", 1}, {"classes.ice", 3}, {"collections.ice", 6}, + {"enums.ice", 2}, {"inheritance.ice", 12}, {"interfaces.ice", 0}, {"json.ice", 2}, {"locals.ice", 7}, + {"optionals.ice", 2}, {"structs.ice", 4}, {"types.ice", 3}, {"xml.ice", 5}}; unsigned int total() { unsigned int t = 0; - for(const auto & c : COMPONENTS_IN_TEST_ICE) { + for (const auto & c : COMPONENTS_IN_TEST_ICE) { t += c.second; } return t; @@ -52,21 +41,21 @@ processAll(Slicer::Slicer & s) { s.includes.push_back(rootDir / "included"); s.includes.push_back(rootDir); - for(const auto & c : COMPONENTS_IN_TEST_ICE) { + for (const auto & c : COMPONENTS_IN_TEST_ICE) { BOOST_TEST_CHECKPOINT(c.first); process(s, c); } BOOST_REQUIRE_EQUAL(total(), s.Components()); } -BOOST_AUTO_TEST_CASE( slicer_test_counts_path ) +BOOST_AUTO_TEST_CASE(slicer_test_counts_path) { Slicer::Slicer s; s.cppPath = "/dev/null"; processAll(s); } -BOOST_AUTO_TEST_CASE( slicer_test_counts_filestar ) +BOOST_AUTO_TEST_CASE(slicer_test_counts_filestar) { FILE * file = fopen("/dev/null", "a"); BOOST_REQUIRE(file); @@ -76,9 +65,8 @@ BOOST_AUTO_TEST_CASE( slicer_test_counts_filestar ) fclose(file); } -BOOST_AUTO_TEST_CASE( slicer_test_counts_nullfilestar ) +BOOST_AUTO_TEST_CASE(slicer_test_counts_nullfilestar) { Slicer::Slicer s; processAll(s); } - diff --git a/slicer/test/serializers.cpp b/slicer/test/serializers.cpp index 0b483b0..3ab54e5 100644 --- a/slicer/test/serializers.cpp +++ b/slicer/test/serializers.cpp @@ -1,126 +1,127 @@ #define BOOST_TEST_MODULE execute_serializers #include <boost/test/unit_test.hpp> -#include <tool/parser.h> -#include <common.h> -#include <slicer.h> -#include <modelParts.h> -#include <xml/serializer.h> -#include <libxml2/libxml/parser.h> -#include <json/serializer.h> +#include "conversions.h" +#include "helpers.h" #include <boost/format.hpp> +#include <common.h> +#include <definedDirs.h> +#include <fstream> #include <functional> -#include <types.h> #include <json.h> -#include <xml.h> +#include <json/serializer.h> +#include <libxml2/libxml/parser.h> #include <locals.h> -#include <fstream> -#include "helpers.h" -#include <definedDirs.h> -#include "conversions.h" +#include <modelParts.h> +#include <slicer.h> +#include <tool/parser.h> +#include <types.h> +#include <xml.h> +#include <xml/serializer.h> #ifdef SLICER_MODELPARTSTYPES_IMPL_H -#error Client code should NOT need to pull in implementation header +# error Client code should NOT need to pull in implementation header #endif namespace fs = std::filesystem; // LCOV_EXCL_START -BOOST_TEST_DONT_PRINT_LOG_VALUE ( TestModule::ClassMap::iterator ) -BOOST_TEST_DONT_PRINT_LOG_VALUE ( TestModule::SomeNumbers ) +BOOST_TEST_DONT_PRINT_LOG_VALUE(TestModule::ClassMap::iterator) +BOOST_TEST_DONT_PRINT_LOG_VALUE(TestModule::SomeNumbers) namespace std { template<typename T> - ostream & operator<<(ostream & s, const Ice::optional<T> &) { + ostream & + operator<<(ostream & s, const Ice::optional<T> &) + { return s; } } // LCOV_EXCL_STOP class FileBased { - public: - template<typename T, typename DeserializerIn> - void - verifyByFile(const fs::path & infile, const std::function<void(const T &)> & check = nullptr) - { - verifyByFile<T, DeserializerIn>(infile, infile, check); +public: + template<typename T, typename DeserializerIn> + void + verifyByFile(const fs::path & infile, const std::function<void(const T &)> & check = nullptr) + { + verifyByFile<T, DeserializerIn>(infile, infile, check); + } + + template<typename T, typename DeserializerIn> + void + verifyByFile(const fs::path & infile, const fs::path & expOutFile, + const std::function<void(const T &)> & check = nullptr) + { + const fs::path input = rootDir / "initial" / infile; + const fs::path expected = rootDir / "initial" / expOutFile; + const fs::path tmpf = binDir / "byFile"; + fs::create_directory(tmpf); + const fs::path output = tmpf / infile; + const fs::path outputJson = tmpf / fs::path(infile).replace_extension("json"); + const fs::path outputXml = tmpf / fs::path(infile).replace_extension("xml"); + + BOOST_TEST_CHECKPOINT("Deserialize: " << input); + T p = Slicer::DeserializeAny<DeserializerIn, T>(input); + + if (check) { + BOOST_TEST_CHECKPOINT("Check1: " << input); + check(p); } - template<typename T, typename DeserializerIn> - void - verifyByFile(const fs::path & infile, const fs::path & expOutFile, const std::function<void(const T &)> & check = nullptr) - { - const fs::path input = rootDir / "initial" / infile; - const fs::path expected = rootDir / "initial" / expOutFile; - const fs::path tmpf = binDir / "byFile"; - fs::create_directory(tmpf); - const fs::path output = tmpf / infile; - const fs::path outputJson = tmpf / fs::path(infile).replace_extension("json"); - const fs::path outputXml = tmpf / fs::path(infile).replace_extension("xml"); - - BOOST_TEST_CHECKPOINT("Deserialize: " << input); - T p = Slicer::DeserializeAny<DeserializerIn, T>(input); - - if (check) { - BOOST_TEST_CHECKPOINT("Check1: " << input); - check(p); - } - - BOOST_TEST_CHECKPOINT("Serialize " << input << " -> " << outputJson); - Slicer::SerializeAny<Slicer::JsonFileSerializer>(p, outputJson); - - BOOST_TEST_CHECKPOINT("Serialize " << input << " -> " << outputXml); - Slicer::SerializeAny<Slicer::XmlFileSerializer>(p, outputXml); - - if (check) { - BOOST_TEST_CHECKPOINT("Check2: " << input); - check(p); - } - - BOOST_TEST_CHECKPOINT("Checksum: " << input << " === " << output); - diff(expected, output); + BOOST_TEST_CHECKPOINT("Serialize " << input << " -> " << outputJson); + Slicer::SerializeAny<Slicer::JsonFileSerializer>(p, outputJson); + + BOOST_TEST_CHECKPOINT("Serialize " << input << " -> " << outputXml); + Slicer::SerializeAny<Slicer::XmlFileSerializer>(p, outputXml); + + if (check) { + BOOST_TEST_CHECKPOINT("Check2: " << input); + check(p); } - template<typename T, typename Deserializer, typename Serializer, typename Internal> - void - verifyByHelper(const fs::path & infile, - const std::function<Internal(const fs::path &)> & in, - const std::function<void(const Internal &, const fs::path &)> & out, - const std::function<void(Internal &)> & ifree, - const std::function<void(const T &)> & check = nullptr) - { - const fs::path input = rootDir / "initial" / infile; - const fs::path tmph = binDir / "byHandler"; - fs::create_directory(tmph); - const fs::path output = tmph / infile; - - BOOST_TEST_CHECKPOINT("Read: " << input); - Internal docRead = in(input); - - BOOST_TEST_CHECKPOINT("Deserialize: " << input); - T p = Slicer::DeserializeAny<Deserializer, T>(docRead); - ifree(docRead); - - if (check) { - BOOST_TEST_CHECKPOINT("Check1: " << input); - check(p); - } - - BOOST_TEST_CHECKPOINT("Serialize: " << input); - Internal docWrite; - Slicer::SerializeAny<Serializer>(p, docWrite); - - if (check) { - BOOST_TEST_CHECKPOINT("Check2: " << input); - check(p); - } - - BOOST_TEST_CHECKPOINT("Write: " << output); - out(docWrite, output); - ifree(docWrite); - - BOOST_TEST_CHECKPOINT("Checksum: " << input << " === " << output); - diff(input, output); + BOOST_TEST_CHECKPOINT("Checksum: " << input << " === " << output); + diff(expected, output); + } + + template<typename T, typename Deserializer, typename Serializer, typename Internal> + void + verifyByHelper(const fs::path & infile, const std::function<Internal(const fs::path &)> & in, + const std::function<void(const Internal &, const fs::path &)> & out, + const std::function<void(Internal &)> & ifree, const std::function<void(const T &)> & check = nullptr) + { + const fs::path input = rootDir / "initial" / infile; + const fs::path tmph = binDir / "byHandler"; + fs::create_directory(tmph); + const fs::path output = tmph / infile; + + BOOST_TEST_CHECKPOINT("Read: " << input); + Internal docRead = in(input); + + BOOST_TEST_CHECKPOINT("Deserialize: " << input); + T p = Slicer::DeserializeAny<Deserializer, T>(docRead); + ifree(docRead); + + if (check) { + BOOST_TEST_CHECKPOINT("Check1: " << input); + check(p); } + + BOOST_TEST_CHECKPOINT("Serialize: " << input); + Internal docWrite; + Slicer::SerializeAny<Serializer>(p, docWrite); + + if (check) { + BOOST_TEST_CHECKPOINT("Check2: " << input); + check(p); + } + + BOOST_TEST_CHECKPOINT("Write: " << output); + out(docWrite, output); + ifree(docWrite); + + BOOST_TEST_CHECKPOINT("Checksum: " << input << " === " << output); + diff(input, output); + } }; void @@ -326,7 +327,7 @@ writeXml(xmlpp::Document * const & doc, const fs::path & path) } void -freeXml(xmlpp::Document * & doc) +freeXml(xmlpp::Document *& doc) { delete doc; } @@ -354,192 +355,194 @@ freeJson(json::Value &) { } -BOOST_FIXTURE_TEST_SUITE ( byFile, FileBased ); +BOOST_FIXTURE_TEST_SUITE(byFile, FileBased); -BOOST_AUTO_TEST_CASE( builtins_xml ) +BOOST_AUTO_TEST_CASE(builtins_xml) { verifyByFile<TestModule::BuiltInsPtr, Slicer::XmlFileDeserializer>("builtins.xml", checkBuiltIns_valuesCorrect); } -BOOST_AUTO_TEST_CASE( structtype_xml ) +BOOST_AUTO_TEST_CASE(structtype_xml) { verifyByFile<TestModule::StructType, Slicer::XmlFileDeserializer>("struct.xml", checkStruct); } -BOOST_AUTO_TEST_CASE( structtype_json ) +BOOST_AUTO_TEST_CASE(structtype_json) { verifyByFile<TestModule::StructType, Slicer::JsonFileDeserializer>("struct2.json", checkStruct); } -BOOST_AUTO_TEST_CASE( simplestring_xml ) +BOOST_AUTO_TEST_CASE(simplestring_xml) { verifyByFile<std::string, Slicer::XmlFileDeserializer>("string.xml", [](const auto & s) { BOOST_REQUIRE_EQUAL("test string", s); }); } -BOOST_AUTO_TEST_CASE( simpleint_xml ) +BOOST_AUTO_TEST_CASE(simpleint_xml) { verifyByFile<Ice::Int, Slicer::XmlFileDeserializer>("int.xml", [](const auto & i) { BOOST_REQUIRE_EQUAL(27, i); }); } -BOOST_AUTO_TEST_CASE( simplestring_json ) +BOOST_AUTO_TEST_CASE(simplestring_json) { verifyByFile<std::string, Slicer::JsonFileDeserializer>("string2.json", [](const auto & s) { BOOST_REQUIRE_EQUAL("test string", s); }); } -BOOST_AUTO_TEST_CASE( simpleint_json ) +BOOST_AUTO_TEST_CASE(simpleint_json) { verifyByFile<Ice::Int, Slicer::JsonFileDeserializer>("int2.json", [](const auto & i) { BOOST_REQUIRE_EQUAL(27, i); }); } -BOOST_AUTO_TEST_CASE( complexClass_xmlattrAndText ) +BOOST_AUTO_TEST_CASE(complexClass_xmlattrAndText) { verifyByFile<TestXml::EntityRef, Slicer::XmlFileDeserializer>("entityref.xml", checkEntityRef); } -BOOST_AUTO_TEST_CASE( sequenceOfClass_xml ) +BOOST_AUTO_TEST_CASE(sequenceOfClass_xml) { verifyByFile<TestModule::Classes, Slicer::XmlFileDeserializer>("seqOfClass.xml", checkSeqOfClass); } -BOOST_AUTO_TEST_CASE( sequenceOfClass_json ) +BOOST_AUTO_TEST_CASE(sequenceOfClass_json) { verifyByFile<TestModule::Classes, Slicer::JsonFileDeserializer>("seqOfClass2.json", checkSeqOfClass); } -BOOST_AUTO_TEST_CASE( optionals_notset_xml ) +BOOST_AUTO_TEST_CASE(optionals_notset_xml) { verifyByFile<TestModule::OptionalsPtr, Slicer::XmlFileDeserializer>("optionals-notset.xml", checkOptionals_notset); } -BOOST_AUTO_TEST_CASE( optionals_areset_xml ) +BOOST_AUTO_TEST_CASE(optionals_areset_xml) { verifyByFile<TestModule::OptionalsPtr, Slicer::XmlFileDeserializer>("optionals-areset.xml", checkOptionals_areset); } -BOOST_AUTO_TEST_CASE( inherit_a_xml ) +BOOST_AUTO_TEST_CASE(inherit_a_xml) { verifyByFile<TestModule::InheritanceContPtr, Slicer::XmlFileDeserializer>("inherit-a.xml"); } -BOOST_AUTO_TEST_CASE( inherit_b_xml ) +BOOST_AUTO_TEST_CASE(inherit_b_xml) { verifyByFile<TestModule::InheritanceContPtr, Slicer::XmlFileDeserializer>("inherit-b.xml", checkInherits_types); } -BOOST_AUTO_TEST_CASE( conv_datetime_xml ) +BOOST_AUTO_TEST_CASE(conv_datetime_xml) { verifyByFile<TestModule::DateTimeContainerPtr, Slicer::XmlFileDeserializer>("conv-datetime.xml"); } -BOOST_AUTO_TEST_CASE( builtins2_json ) +BOOST_AUTO_TEST_CASE(builtins2_json) { verifyByFile<TestModule::BuiltInsPtr, Slicer::JsonFileDeserializer>("builtins2.json", checkBuiltIns_valuesCorrect); } -BOOST_AUTO_TEST_CASE( builtins3_json ) +BOOST_AUTO_TEST_CASE(builtins3_json) { verifyByFile<TestModule::BuiltInsPtr, Slicer::JsonFileDeserializer>("builtins3.json", checkBuiltIns3_valuesCorrect); } -BOOST_AUTO_TEST_CASE( optionals_areset2_json ) +BOOST_AUTO_TEST_CASE(optionals_areset2_json) { - verifyByFile<TestModule::OptionalsPtr, Slicer::JsonFileDeserializer>("optionals-areset2.json", checkOptionals_areset); + verifyByFile<TestModule::OptionalsPtr, Slicer::JsonFileDeserializer>( + "optionals-areset2.json", checkOptionals_areset); } -BOOST_AUTO_TEST_CASE( inherit_c_json ) +BOOST_AUTO_TEST_CASE(inherit_c_json) { verifyByFile<TestModule::InheritanceContPtr, Slicer::JsonFileDeserializer>("inherit-c.json", checkInherits_types); } -BOOST_AUTO_TEST_CASE( inherit_d_json ) +BOOST_AUTO_TEST_CASE(inherit_d_json) { verifyByFile<TestModule::InheritanceCont2Ptr, Slicer::JsonFileDeserializer>("inherit-d.json"); } -BOOST_AUTO_TEST_CASE( inherit_mapped_json ) +BOOST_AUTO_TEST_CASE(inherit_mapped_json) { verifyByFile<TestModule::InheritanceContMappedPtr, Slicer::JsonFileDeserializer>("inherit-mapped.json"); } -BOOST_AUTO_TEST_CASE( xml_attribute_xml ) +BOOST_AUTO_TEST_CASE(xml_attribute_xml) { verifyByFile<TestModule::ClassClassPtr, Slicer::XmlFileDeserializer>("xmlattr.xml"); } -BOOST_AUTO_TEST_CASE( xml_barecontainers_xml ) +BOOST_AUTO_TEST_CASE(xml_barecontainers_xml) { verifyByFile<TestXml::BareContainers, Slicer::XmlFileDeserializer>("bare.xml", checkBare); } -BOOST_AUTO_TEST_CASE( xml_classOfEnums_xml ) +BOOST_AUTO_TEST_CASE(xml_classOfEnums_xml) { verifyByFile<TestModule::SomeEnumsPtr, Slicer::XmlFileDeserializer>("someenums.xml", checkSomeEnums); } -BOOST_AUTO_TEST_CASE( xml_rootEnums_xml ) +BOOST_AUTO_TEST_CASE(xml_rootEnums_xml) { verifyByFile<TestModule::SomeNumbers, Slicer::XmlFileDeserializer>("enum.xml", checkSomeNumbers); } -BOOST_AUTO_TEST_CASE( xml_attributemap_xml ) +BOOST_AUTO_TEST_CASE(xml_attributemap_xml) { verifyByFile<TestXml::Maps, Slicer::XmlFileDeserializer>("attributemap.xml", attributeMap); } -BOOST_AUTO_TEST_CASE( xml_elementmap_xml ) +BOOST_AUTO_TEST_CASE(xml_elementmap_xml) { verifyByFile<TestXml::Maps, Slicer::XmlFileDeserializer>("elementmap.xml", elementMap); } -BOOST_AUTO_TEST_CASE( json_rootEnums_json ) +BOOST_AUTO_TEST_CASE(json_rootEnums_json) { verifyByFile<TestModule::SomeNumbers, Slicer::JsonFileDeserializer>("enum2.json", checkSomeNumbers); } -BOOST_AUTO_TEST_CASE( json_objectmap ) +BOOST_AUTO_TEST_CASE(json_objectmap) { verifyByFile<TestJson::Properties, Slicer::JsonFileDeserializer>("objectmap.json", checkObjectMap); } -BOOST_AUTO_TEST_CASE( json_objectmapMember ) +BOOST_AUTO_TEST_CASE(json_objectmapMember) { - verifyByFile<TestJson::HasProperitiesPtr, Slicer::JsonFileDeserializer>("objectmapMember.json", checkObjectMapMember); + verifyByFile<TestJson::HasProperitiesPtr, Slicer::JsonFileDeserializer>( + "objectmapMember.json", checkObjectMapMember); } -BOOST_AUTO_TEST_CASE( json_localClass ) +BOOST_AUTO_TEST_CASE(json_localClass) { verifyByFile<Locals::LocalClassPtr, Slicer::JsonFileDeserializer>("localClass.json"); } -BOOST_AUTO_TEST_CASE( json_localSub2Class ) +BOOST_AUTO_TEST_CASE(json_localSub2Class) { verifyByFile<Locals::LocalClassPtr, Slicer::JsonFileDeserializer>("localSub2Class.json"); } -BOOST_AUTO_TEST_CASE( json_localSubClass ) +BOOST_AUTO_TEST_CASE(json_localSubClass) { verifyByFile<Locals::LocalSubClassPtr, Slicer::JsonFileDeserializer>("localSub2Class.json"); } -BOOST_AUTO_TEST_CASE( json_simpleArray ) +BOOST_AUTO_TEST_CASE(json_simpleArray) { verifyByFile<TestModule::SimpleSeq, Slicer::JsonFileDeserializer>("simpleArray1.json"); } -BOOST_AUTO_TEST_CASE( xml_simpleArray ) +BOOST_AUTO_TEST_CASE(xml_simpleArray) { verifyByFile<TestModule::SimpleSeq, Slicer::XmlFileDeserializer>("simpleArray2.xml"); } -BOOST_AUTO_TEST_CASE( json_emptyToNull ) +BOOST_AUTO_TEST_CASE(json_emptyToNull) { verifyByFile<TestModule::Optionals2Ptr, Slicer::JsonFileDeserializer>("optionals2.json", [](const auto & o) { BOOST_REQUIRE(o); @@ -548,7 +551,7 @@ BOOST_AUTO_TEST_CASE( json_emptyToNull ) }); } -BOOST_AUTO_TEST_CASE( json_emptyToNull_withValue ) +BOOST_AUTO_TEST_CASE(json_emptyToNull_withValue) { verifyByFile<TestModule::Optionals2Ptr, Slicer::JsonFileDeserializer>("optionals3.json", [](const auto & o) { BOOST_REQUIRE(o); @@ -558,16 +561,17 @@ BOOST_AUTO_TEST_CASE( json_emptyToNull_withValue ) }); } -BOOST_AUTO_TEST_CASE( json_emptyToNull_omitted ) +BOOST_AUTO_TEST_CASE(json_emptyToNull_omitted) { - verifyByFile<TestModule::Optionals2Ptr, Slicer::JsonFileDeserializer>("optionals5.json", "optionals2.json", [](const auto & o) { - BOOST_REQUIRE(o); - BOOST_REQUIRE(!o->optConverted); - BOOST_REQUIRE_EQUAL(o->nonOptConverted, 4); - }); + verifyByFile<TestModule::Optionals2Ptr, Slicer::JsonFileDeserializer>( + "optionals5.json", "optionals2.json", [](const auto & o) { + BOOST_REQUIRE(o); + BOOST_REQUIRE(!o->optConverted); + BOOST_REQUIRE_EQUAL(o->nonOptConverted, 4); + }); } -BOOST_AUTO_TEST_CASE( json_streams ) +BOOST_AUTO_TEST_CASE(json_streams) { const auto tmpf = binDir / "byStream"; const auto inFile = rootDir / "initial" / "inherit-c.json"; @@ -583,7 +587,7 @@ BOOST_AUTO_TEST_CASE( json_streams ) diff(inFile, outFile); } -BOOST_AUTO_TEST_CASE( xml_streams ) +BOOST_AUTO_TEST_CASE(xml_streams) { const auto tmpf = binDir / "byStream"; const auto inFile = rootDir / "initial" / "inherit-b.xml"; @@ -599,50 +603,51 @@ BOOST_AUTO_TEST_CASE( xml_streams ) diff(inFile, outFile); } -BOOST_AUTO_TEST_CASE( invalid_enum ) +BOOST_AUTO_TEST_CASE(invalid_enum) { auto jdeserializer = std::make_shared<Slicer::JsonFileDeserializer>(rootDir / "initial" / "invalidEnum.json"); - BOOST_REQUIRE_THROW(Slicer::DeserializeAnyWith<TestModule::SomeNumbers>(jdeserializer), Slicer::InvalidEnumerationSymbol); + BOOST_REQUIRE_THROW( + Slicer::DeserializeAnyWith<TestModule::SomeNumbers>(jdeserializer), Slicer::InvalidEnumerationSymbol); auto xdeserializer = std::make_shared<Slicer::XmlFileDeserializer>(rootDir / "initial" / "invalidEnum.xml"); - BOOST_REQUIRE_THROW(Slicer::DeserializeAnyWith<TestModule::SomeNumbers>(xdeserializer), Slicer::InvalidEnumerationSymbol); + BOOST_REQUIRE_THROW( + Slicer::DeserializeAnyWith<TestModule::SomeNumbers>(xdeserializer), Slicer::InvalidEnumerationSymbol); } BOOST_AUTO_TEST_SUITE_END(); +BOOST_FIXTURE_TEST_SUITE(byHandler, FileBased); -BOOST_FIXTURE_TEST_SUITE ( byHandler, FileBased ); - -BOOST_AUTO_TEST_CASE( optionals_areset2_json ) +BOOST_AUTO_TEST_CASE(optionals_areset2_json) { - verifyByHelper<TestModule::OptionalsPtr, Slicer::JsonValueDeserializer, Slicer::JsonValueSerializer, json::Value>("optionals-areset2.json", readJson, writeJson, freeJson, checkOptionals_areset); + verifyByHelper<TestModule::OptionalsPtr, Slicer::JsonValueDeserializer, Slicer::JsonValueSerializer, json::Value>( + "optionals-areset2.json", readJson, writeJson, freeJson, checkOptionals_areset); } -BOOST_AUTO_TEST_CASE( optionals_areset_xml ) +BOOST_AUTO_TEST_CASE(optionals_areset_xml) { - verifyByHelper<TestModule::OptionalsPtr, Slicer::XmlDocumentDeserializer, Slicer::XmlDocumentSerializer, xmlpp::Document *>("optionals-areset.xml", readXml, writeXml, freeXml, checkOptionals_areset); + verifyByHelper<TestModule::OptionalsPtr, Slicer::XmlDocumentDeserializer, Slicer::XmlDocumentSerializer, + xmlpp::Document *>("optionals-areset.xml", readXml, writeXml, freeXml, checkOptionals_areset); } -BOOST_AUTO_TEST_CASE( simple_complete_validator ) +BOOST_AUTO_TEST_CASE(simple_complete_validator) { - verifyByHelper<TestModule::IsoDate, Slicer::XmlDocumentDeserializer, Slicer::XmlDocumentSerializer, xmlpp::Document *>("isodate.xml", readXml, writeXml, freeXml); + verifyByHelper<TestModule::IsoDate, Slicer::XmlDocumentDeserializer, Slicer::XmlDocumentSerializer, + xmlpp::Document *>("isodate.xml", readXml, writeXml, freeXml); } -BOOST_AUTO_TEST_CASE( missingConversion ) +BOOST_AUTO_TEST_CASE(missingConversion) { auto in = json::parseValue(R"J({"conv": "2016-06-30 12:34:56"})J"); - BOOST_REQUIRE_THROW(( - Slicer::DeserializeAny<Slicer::JsonValueDeserializer, TestModule2::MissingConvPtr>(in) - ), Slicer::NoConversionFound); + BOOST_REQUIRE_THROW((Slicer::DeserializeAny<Slicer::JsonValueDeserializer, TestModule2::MissingConvPtr>(in)), + Slicer::NoConversionFound); auto obj = std::make_shared<TestModule2::MissingConv>("2016-06-30 12:34:56"); json::Value v; - BOOST_REQUIRE_THROW( - Slicer::SerializeAny<Slicer::JsonValueSerializer>(obj, v), - Slicer::NoConversionFound); + BOOST_REQUIRE_THROW(Slicer::SerializeAny<Slicer::JsonValueSerializer>(obj, v), Slicer::NoConversionFound); } -BOOST_AUTO_TEST_CASE( conversion ) +BOOST_AUTO_TEST_CASE(conversion) { auto in = json::parseValue(R"J({"conv": "2016-06-30 12:34:56"})J"); auto obj = Slicer::DeserializeAny<Slicer::JsonValueDeserializer, TestModule2::ConvPtr>(in); @@ -650,13 +655,12 @@ BOOST_AUTO_TEST_CASE( conversion ) json::Value v; Slicer::SerializeAny<Slicer::JsonValueSerializer>(obj, v); - BOOST_REQUIRE_EQUAL("2016-06-30 12:34:56", - std::get<json::String>(std::get<json::Object>(v)["conv"])); + BOOST_REQUIRE_EQUAL("2016-06-30 12:34:56", std::get<json::String>(std::get<json::Object>(v)["conv"])); } BOOST_AUTO_TEST_SUITE_END(); -BOOST_AUTO_TEST_CASE( customerModelPartCounters ) +BOOST_AUTO_TEST_CASE(customerModelPartCounters) { BOOST_REQUIRE_EQUAL(21, TestModule::completions); } @@ -666,7 +670,7 @@ BOOST_FIXTURE_TEST_SUITE(l, Slicer::case_less); BOOST_AUTO_TEST_CASE(case_less_test) { using namespace std::literals; - const auto & lc { *this }; + const auto & lc {*this}; BOOST_CHECK(!lc(""sv, ""sv)); BOOST_CHECK(lc("a"sv, "b"sv)); BOOST_CHECK(lc("A"sv, "b"sv)); @@ -686,4 +690,3 @@ BOOST_AUTO_TEST_CASE(enum_lookups) BOOST_CHECK_EQUAL("One", Slicer::ModelPartForEnum<TestModule::SomeNumbers>::lookup(TestModule::SomeNumbers::One)); BOOST_CHECK_EQUAL(TestModule::SomeNumbers::One, Slicer::ModelPartForEnum<TestModule::SomeNumbers>::lookup("One")); } - diff --git a/slicer/test/streams-mp.cpp b/slicer/test/streams-mp.cpp index 119ee1f..5764248 100644 --- a/slicer/test/streams-mp.cpp +++ b/slicer/test/streams-mp.cpp @@ -1,5 +1,4 @@ -#include <slicer/modelPartsTypes.impl.h> #include "streams.h" +#include <slicer/modelPartsTypes.impl.h> MODELPARTFORSTREAM(TestStream); - diff --git a/slicer/test/streams.cpp b/slicer/test/streams.cpp index 3ea4933..e68de0e 100644 --- a/slicer/test/streams.cpp +++ b/slicer/test/streams.cpp @@ -1,15 +1,16 @@ #define BOOST_TEST_MODULE streams #include <boost/test/unit_test.hpp> -#include <xml/serializer.h> -#include <json/serializer.h> -#include <slicer.h> -#include <collections.h> -#include <definedDirs.h> #include "helpers.h" #include "streams.h" +#include <collections.h> +#include <definedDirs.h> +#include <json/serializer.h> +#include <slicer.h> +#include <xml/serializer.h> -void TestStream::Produce(const Consumer & c) +void +TestStream::Produce(const Consumer & c) { for (int x = 0; x < 10; x += 1) { auto str = std::to_string(x); @@ -17,9 +18,9 @@ void TestStream::Produce(const Consumer & c) } } -BOOST_FIXTURE_TEST_SUITE( stream, TestStream ); +BOOST_FIXTURE_TEST_SUITE(stream, TestStream); -BOOST_AUTO_TEST_CASE( streamToXml ) +BOOST_AUTO_TEST_CASE(streamToXml) { const auto outputXml = binDir / "streamOut.xml"; Slicer::SerializeAny<Slicer::XmlFileSerializer, const TestStream>(*this, outputXml); @@ -30,7 +31,7 @@ BOOST_AUTO_TEST_CASE( streamToXml ) BOOST_REQUIRE_EQUAL("9", seq.back()); } -BOOST_AUTO_TEST_CASE( streamToJson ) +BOOST_AUTO_TEST_CASE(streamToJson) { const auto outputJson = binDir / "streamOut.json"; Slicer::SerializeAny<Slicer::JsonFileSerializer, const TestStream>(*this, outputJson); @@ -42,4 +43,3 @@ BOOST_AUTO_TEST_CASE( streamToJson ) } BOOST_AUTO_TEST_SUITE_END(); - diff --git a/slicer/test/streams.h b/slicer/test/streams.h index 28c0c9d..bf80ce2 100644 --- a/slicer/test/streams.h +++ b/slicer/test/streams.h @@ -4,9 +4,8 @@ #include <slicer/modelPartsTypes.h> class TestStream : public Slicer::Stream<std::string> { - public: - void Produce(const Consumer & c) override; +public: + void Produce(const Consumer & c) override; }; #endif - diff --git a/slicer/tool/Jamfile.jam b/slicer/tool/Jamfile.jam index fe45a72..e8ef3e9 100644 --- a/slicer/tool/Jamfile.jam +++ b/slicer/tool/Jamfile.jam @@ -16,8 +16,6 @@ lib slicer-compiler : <implicit-dependency>../slicer//slicer <include>.. <toolset>tidy:<xcheckxx>clang-analyzer-cplusplus.NewDelete - <toolset>tidy:<xcheckxx>clang-analyzer-cplusplus.InnerPointer - <toolset>tidy:<xcheckxx>clang-analyzer-cplusplus.NewDeleteLeaks : : <include>.. <library>../slicer//slicer diff --git a/slicer/tool/parser.cpp b/slicer/tool/parser.cpp index 294dd7a..d342c35 100644 --- a/slicer/tool/parser.cpp +++ b/slicer/tool/parser.cpp @@ -1,31 +1,34 @@ #include "parser.h" -#include <metadata.h> -#include <common.h> +#include <Slice/CPlusPlusUtil.h> #include <Slice/Parser.h> #include <Slice/Preprocessor.h> #include <boost/algorithm/string/predicate.hpp> #include <boost/algorithm/string/replace.hpp> -#include <boost/algorithm/string/trim.hpp> #include <boost/algorithm/string/split.hpp> -#include <Slice/CPlusPlusUtil.h> +#include <boost/algorithm/string/trim.hpp> +#include <common.h> #include <fprintbf.h> +#include <metadata.h> #include <safeMapFind.h> namespace fs = std::filesystem; namespace Slicer { - Slicer::Slicer() : - cpp(nullptr), - headerPrefix("slicer"), - components(0), - classNo(0) + template<typename TPtr> + bool + ignoreType(const TPtr & t) { + return (!t || t->hasMetaData("slicer:ignore")); } + Slicer::Slicer() : cpp(nullptr), headerPrefix("slicer"), components(0), classNo(0) { } + void Slicer::defineConversions(const Slice::DataMemberPtr & dm) const { - if (!cpp) { return; } + if (!cpp) { + return; + } auto type = dm->type(); auto c = Slice::ContainedPtr::dynamicCast(dm->container()); @@ -33,16 +36,12 @@ namespace Slicer { for (const auto & conversion : conversions) { if (!AdHoc::containerContains(conversion.Options, "nodeclare")) { if (!AdHoc::containerContains(conversion.Options, "nodeclareto")) { - fprintbf(cpp, "DLL_PUBLIC %s %s(const %s &);\n", - conversion.ExchangeType, - conversion.ConvertToExchangeFunc, - Slice::typeToString(type)); + fprintbf(cpp, "DLL_PUBLIC %s %s(const %s &);\n", conversion.ExchangeType, + conversion.ConvertToExchangeFunc, Slice::typeToString(type)); } if (!AdHoc::containerContains(conversion.Options, "nodeclarefrom")) { - fprintbf(cpp, "DLL_PUBLIC %s %s(const %s &);\n\n", - Slice::typeToString(type), - conversion.ConvertToModelFunc, - conversion.ExchangeType); + fprintbf(cpp, "DLL_PUBLIC %s %s(const %s &);\n\n", Slice::typeToString(type), + conversion.ConvertToModelFunc, conversion.ExchangeType); } } } @@ -55,8 +54,7 @@ namespace Slicer { for (const auto & conversion : conversions) { fprintbf(cpp, "\tif (tryConvertFrom< %s >(vsp, Model, &%s)) {\n\t\treturn;\n\t}\n", - conversion.ExchangeType, - conversion.ConvertToModelFunc); + conversion.ExchangeType, conversion.ConvertToModelFunc); } // Default conversion if (!dm->hasMetaData("slicer:nodefaultconversion")) { @@ -64,8 +62,7 @@ namespace Slicer { Slice::typeToString(type)); } // Failed to convert - fprintbf(cpp, "\tthrow NoConversionFound(\"%s\");\n", - Slice::typeToString(type)); + fprintbf(cpp, "\tthrow NoConversionFound(\"%s\");\n", Slice::typeToString(type)); fprintbf(cpp, "}\n\n"); fprintbf(cpp, "template<> DLL_PUBLIC\nbool\n"); @@ -75,18 +72,22 @@ namespace Slicer { fprintbf(cpp, "\tBOOST_ASSERT(Model);\n"); for (const auto & conversion : conversions) { - fprintbf(cpp, "\tif (auto r = tryConvertTo< %s >(vtp, Model, &%s)) {\n\t\treturn (r == tcr_Value);\n\t}\n", - conversion.ExchangeType, - conversion.ConvertToExchangeFunc); + fprintbf(cpp, + "\tif (auto r = tryConvertTo< %s >(vtp, Model, &%s); r != TryConvertResult::NoAction) {\n" + "\t\treturn (r == TryConvertResult::Value);\n" + "\t}\n", + conversion.ExchangeType, conversion.ConvertToExchangeFunc); } // Default conversion if (!dm->hasMetaData("slicer:nodefaultconversion")) { - fprintbf(cpp, "\tif (auto r = tryConvertTo< %s >(vtp, Model)) {\n\t\treturn (r == tcr_Value);\n\t}\n", - Slice::typeToString(type)); + fprintbf(cpp, + "\tif (auto r = tryConvertTo< %s >(vtp, Model); r != TryConvertResult::NoAction) {\n" + "\t\treturn (r == TryConvertResult::Value);\n" + "\t}\n", + Slice::typeToString(type)); } // Failed to convert - fprintbf(cpp, "\tthrow NoConversionFound(\"%s\");\n", - Slice::typeToString(type)); + fprintbf(cpp, "\tthrow NoConversionFound(\"%s\");\n", Slice::typeToString(type)); fprintbf(cpp, "}\n\n"); } } @@ -95,7 +96,9 @@ namespace Slicer { Slicer::visitUnitStart(const Slice::UnitPtr & u) { fs::path topLevelFile(u->topLevelFile()); - if (!cpp) { return true; } + if (!cpp) { + return true; + } fprintbf(cpp, "// Begin Slicer code\n\n"); fprintbf(cpp, "#include <%s>\n\n", (headerPrefix / "modelPartsTypes.impl.h").string()); @@ -111,9 +114,11 @@ namespace Slicer { } void - Slicer::visitUnitEnd(const Slice::UnitPtr&) + Slicer::visitUnitEnd(const Slice::UnitPtr &) { - if (!cpp) { return; } + if (!cpp) { + return; + } fprintbf(cpp, "}\n\n"); fprintbf(cpp, "// End Slicer code\n\n"); @@ -122,7 +127,9 @@ namespace Slicer { bool Slicer::visitModuleStart(const Slice::ModulePtr & m) { - if (!cpp) { return true; } + if (!cpp) { + return true; + } fprintbf(cpp, "// Begin module %s\n\n", m->name()); for (const auto & c : m->structs()) { @@ -143,44 +150,48 @@ namespace Slicer { { if (stype->isLocal()) { fprintbf(cpp, "template<>\n"); - fprintbf(cpp, "struct isLocal< %s > { static constexpr bool value = true; };\n\n", - type); + fprintbf(cpp, "struct isLocal< %s > { static constexpr bool value = true; };\n\n", type); } fprintbf(cpp, "template<> DLL_PUBLIC\n"); - fprintbf(cpp, "const std::string ModelPartForRoot< %s >::rootName(\"%s\");\n\n", - type, name); + fprintbf(cpp, "const std::string ModelPartForRoot< %s >::rootName(\"%s\");\n\n", type, name); fprintbf(cpp, "template<> DLL_PUBLIC\n"); - fprintbf(cpp, "const std::string ModelPartForRoot< Ice::optional< %s > >::rootName(\"Optional%s\");\n\n", - type, name); + fprintbf(cpp, "const std::string ModelPartForRoot< Ice::optional< %s > >::rootName(\"Optional%s\");\n\n", type, + name); } void Slicer::externType(const Slice::TypePtr & type) const { - if (definedTypes.count(type->typeId())) return; - - fprintbf(cpp, "extern template class %s< %s >;\n", - getBasicModelPart(type), Slice::ClassDeclPtr::dynamicCast(type) ? type->typeId() : Slice::typeToString(type)); + if (definedTypes.count(type->typeId())) { + return; + } + fprintbf(cpp, "extern template class %s< %s >;\n", getBasicModelPart(type), + Slice::ClassDeclPtr::dynamicCast(type) ? type->typeId() : Slice::typeToString(type)); } bool Slicer::visitClassDefStart(const Slice::ClassDefPtr & c) { - if (c->isInterface()) { return false; } - if (c->hasMetaData("slicer:ignore")) { return false; } + if (c->isInterface()) { + return false; + } + if (ignoreType(c)) { + return false; + } components += 1; - if (!cpp) { return true; } + if (!cpp) { + return true; + } auto decl = c->declaration(); fprintbf(cpp, "// Class %s\n", c->name()); - visitComplexDataMembers(decl, c->allDataMembers()); + visitComplexDataMembers(decl.get(), c->allDataMembers()); fprintbf(cpp, "template<> DLL_PUBLIC\n"); auto typeId = metaDataValue("slicer:typeid:", c->getMetaData()); - fprintbf(cpp, "const std::string ModelPartForClass< %s >::typeIdProperty(\"%s\");\n\n", - decl->typeId(), + fprintbf(cpp, "const std::string ModelPartForClass< %s >::typeIdProperty(\"%s\");\n\n", decl->typeId(), typeId ? *typeId : "slicer-typeid"); auto name = metaDataValue("slicer:root:", c->getMetaData()); @@ -188,31 +199,28 @@ namespace Slicer { auto typeName = metaDataValue("slicer:typename:", c->getMetaData()); fprintbf(cpp, "template<> DLL_PUBLIC\n"); - fprintbf(cpp, "const std::string * ModelPartForClass< %s >::className = nullptr;\n", - decl->typeId()); + fprintbf(cpp, "const std::string * ModelPartForClass< %s >::className = nullptr;\n", decl->typeId()); fprintbf(cpp, "template<> DLL_PUBLIC\n"); - fprintbf(cpp, "const std::string * ModelPartForClass< %s >::typeName = nullptr;\n", - decl->typeId()); - fprintbf(cpp, "template<>\nvoid ModelPartForClass< %s >::initClassName() {\n\tclassName = new std::string(\"%s\");\n\t", + fprintbf(cpp, "const std::string * ModelPartForClass< %s >::typeName = nullptr;\n", decl->typeId()); + fprintbf(cpp, + "template<>\nvoid ModelPartForClass< %s >::initClassName() {\n\tclassName = new " + "std::string(\"%s\");\n\t", decl->typeId(), c->scoped()); if (typeName) { - fprintbf(cpp, "typeName = new std::string(\"%s\");", - *typeName); + fprintbf(cpp, "typeName = new std::string(\"%s\");", *typeName); } else { fprintbf(cpp, "typeName = nullptr;"); } fprintbf(cpp, "\n}\n"); - fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForComplex< %s >::metadata ", - c->scoped()); + fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForComplex< %s >::metadata ", c->scoped()); copyMetadata(c->getMetaData()); fprintbf(cpp, ";\n\n"); - fprintbf(cpp, "// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)\n"); if (auto cmp = metaDataValue("slicer:custommodelpart:", c->getMetaData())) { - fprintbf(cpp, "CUSTOMMODELPARTFOR(%s, %s< %s >, %s);\n\n", - Slice::typeToString(decl), getBasicModelPart(decl), c->scoped(), boost::algorithm::replace_all_copy(*cmp, ".", "::")); + fprintbf(cpp, "CUSTOMMODELPARTFOR(%s, %s< %s >, %s);\n\n", Slice::typeToString(decl), + getBasicModelPart(decl), c->scoped(), boost::algorithm::replace_all_copy(*cmp, ".", "::")); } else { fprintbf(cpp, "CUSTOMMODELPARTFOR(%s, ModelPartForClass<%s>, ModelPartForClass<%s>);\n\n", @@ -228,20 +236,23 @@ namespace Slicer { bool Slicer::visitStructStart(const Slice::StructPtr & c) { - if (c->hasMetaData("slicer:ignore")) { return false; } + if (ignoreType(c)) { + return false; + } components += 1; - if (!cpp) { return true; } + if (!cpp) { + return true; + } fprintbf(cpp, "// Struct %s\n", c->name()); - visitComplexDataMembers(c, c->dataMembers()); + visitComplexDataMembers(c.get(), c->dataMembers()); auto name = metaDataValue("slicer:root:", c->getMetaData()); defineRoot(c->scoped(), name ? *name : c->name(), c); - fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForComplex< %s >::metadata ", - c->scoped()); + fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForComplex< %s >::metadata ", c->scoped()); copyMetadata(c->getMetaData()); fprintbf(cpp, ";\n\n"); @@ -253,20 +264,18 @@ namespace Slicer { void Slicer::visitComplexDataMembers(const Slice::ConstructedPtr & it, const Slice::DataMemberList & dataMembers) const { - if (!cpp) { return; } + if (!cpp) { + return; + } for (const auto & dm : dataMembers) { externType(dm->type()); } - fprintbf(cpp, "using C%d = ModelPartForComplex< %s >;\n", - components, it->scoped()); + fprintbf(cpp, "using C%d = ModelPartForComplex< %s >;\n", components, it->scoped()); fprintbf(cpp, "template<> DLL_PUBLIC\n"); - fprintbf(cpp, "const C%d::Hooks ", - components); - fprintbf(cpp, "C%d::hooks ([](){\n", - components); - fprintbf(cpp, "\t\tC%d::Hooks r;\n", - components); + fprintbf(cpp, "const C%d::Hooks ", components); + fprintbf(cpp, "C%d::hooks ([](){\n", components); + fprintbf(cpp, "\t\tC%d::Hooks r;\n", components); for (const auto & dm : dataMembers) { auto c = Slice::ContainedPtr::dynamicCast(dm->container()); auto t = Slice::TypePtr::dynamicCast(dm->container()); @@ -274,8 +283,7 @@ namespace Slicer { t = Slice::ClassDefPtr::dynamicCast(dm->container())->declaration(); } auto name = metaDataValue("slicer:name:", dm->getMetaData()).value_or(dm->name()); - fprintbf(cpp, "\t\tC%d::addHook<C%d::", - components, components); + fprintbf(cpp, "\t\tC%d::addHook<C%d::", components, components); auto type = dm->type(); if (hasMetadata(dm->getMetaData())) { fprintbf(cpp, "HookMetadata<"); @@ -283,12 +291,9 @@ namespace Slicer { else { fprintbf(cpp, "Hook<"); } - fprintbf(cpp, " %s, ", - Slice::typeToString(type, dm->optional())); + fprintbf(cpp, " %s, ", Slice::typeToString(type, dm->optional())); createNewModelPartPtrFor(type, dm, getAllMetadata(dm)); - fprintbf(cpp, " > >(r, &%s, \"%s\"", - dm->scoped(), - name); + fprintbf(cpp, " > >(r, &%s, \"%s\"", dm->scoped(), name); if (hasMetadata(dm->getMetaData())) { fprintbf(cpp, ", Metadata "); copyMetadata(dm->getMetaData()); @@ -302,31 +307,34 @@ namespace Slicer { void Slicer::visitEnum(const Slice::EnumPtr & e) { - if (e->hasMetaData("slicer:ignore")) { return; } + if (ignoreType(e)) { + return; + } components += 1; - if (!cpp) { return; } + if (!cpp) { + return; + } fprintbf(cpp, "// Enumeration %s\n", e->name()); - fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForEnum< %s >::metadata ", - e->scoped()); + fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForEnum< %s >::metadata ", e->scoped()); copyMetadata(e->getMetaData()); fprintbf(cpp, ";\n\n"); - fprintbf(cpp, "template<> DLL_PUBLIC\nconst ModelPartForEnum< %s >::Enumerations\nModelPartForEnum< %s >::enumerations([]() -> ModelPartForEnum< %s >::Enumerations\n", - e->scoped(), - e->scoped(), - e->scoped()); - fprintbf(cpp, "{\n\tModelPartForEnum< %s >::Enumerations e;\n", - e->scoped()); + fprintbf(cpp, + "template<> DLL_PUBLIC\nconst ModelPartForEnum< %s >::Enumerations\nModelPartForEnum< %s " + ">::enumerations([]() -> ModelPartForEnum< %s >::Enumerations\n", + e->scoped(), e->scoped(), e->scoped()); + fprintbf(cpp, "{\n\tModelPartForEnum< %s >::Enumerations e;\n", e->scoped()); for (const auto & ee : e->enumerators()) { fprintbf(cpp, "\te.insert( { %s, \"%s\" } );\n", ee->scoped(), ee->name()); } fprintbf(cpp, "\treturn e;\n}());\n\n"); auto name = metaDataValue("slicer:root:", e->getMetaData()); - defineRoot(e->scoped(), name ? *name : e->name(), e); + const Slice::TypePtr t = e; + defineRoot(e->scoped(), name ? *name : e->name(), t); defineMODELPART(e->scoped(), e, e->getMetaData()); } @@ -334,20 +342,28 @@ namespace Slicer { void Slicer::visitSequence(const Slice::SequencePtr & s) { - if (s->hasMetaData("slicer:ignore")) { return; } + if (ignoreType(s)) { + return; + } components += 1; - if (!cpp) { return; } + if (!cpp) { + return; + } fprintbf(cpp, "// Sequence %s\n", s->name()); externType(s->type()); fprintbf(cpp, "template<> DLL_PUBLIC\n"); - fprintbf(cpp, "ChildRef ModelPartForSequence< %s >::GetChildRef(const std::string & name, const HookFilter & flt, bool matchCase)\n{\n", + fprintbf(cpp, + "ChildRef ModelPartForSequence< %s >::GetChildRef(const std::string & name, const HookFilter & flt, " + "bool matchCase)\n{\n", s->scoped()); auto iname = metaDataValue("slicer:item:", s->getMetaData()); if (iname) { - fprintbf(cpp, "\tif (!name.empty() && !optionalCaseEq(name, \"%s\", matchCase)) { throw IncorrectElementName(name); }\n", + fprintbf(cpp, + "\tif (!name.empty() && !optionalCaseEq(name, \"%s\", matchCase)) { throw " + "IncorrectElementName(name); }\n", *iname); } else { @@ -358,15 +374,13 @@ namespace Slicer { fprintbf(cpp, "template<> DLL_PUBLIC\n"); auto ename = metaDataValue("slicer:element:", s->getMetaData()); - fprintbf(cpp, "const std::string ModelPartForSequence< %s >::elementName(\"%s\");\n\n", - s->scoped(), + fprintbf(cpp, "const std::string ModelPartForSequence< %s >::elementName(\"%s\");\n\n", s->scoped(), ename ? *ename : "element"); auto name = metaDataValue("slicer:root:", s->getMetaData()); defineRoot(s->scoped(), name ? *name : s->name(), s); - fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForSequence< %s >::metadata ", - s->scoped()); + fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForSequence< %s >::metadata ", s->scoped()); copyMetadata(s->getMetaData()); fprintbf(cpp, ";\n\n"); @@ -376,40 +390,34 @@ namespace Slicer { void Slicer::visitDictionary(const Slice::DictionaryPtr & d) { - if (d->hasMetaData("slicer:ignore")) { return; } + if (ignoreType(d)) { + return; + } components += 1; - if (!cpp) { return; } + if (!cpp) { + return; + } fprintbf(cpp, "// Dictionary %s\n", d->name()); externType(d->keyType()); externType(d->valueType()); auto iname = metaDataValue("slicer:item:", d->getMetaData()); fprintbf(cpp, "template<> DLL_PUBLIC\n"); - fprintbf(cpp, "const std::string ModelPartForDictionary< %s >::pairName(\"%s\");\n\n", - d->scoped(), + fprintbf(cpp, "const std::string ModelPartForDictionary< %s >::pairName(\"%s\");\n\n", d->scoped(), iname ? *iname : "element"); - fprintbf(cpp, "using C%d = ModelPartForComplex< %s::value_type >;\n", - components, d->scoped()); + fprintbf(cpp, "using C%d = ModelPartForComplex< %s::value_type >;\n", components, d->scoped()); fprintbf(cpp, "template<> DLL_PUBLIC\n"); - fprintbf(cpp, "const C%d::Hooks ", - components); - fprintbf(cpp, "C%d::hooks ([](){\n", - components); - fprintbf(cpp, "\t\tC%d::Hooks r;\n", - components); + fprintbf(cpp, "const C%d::Hooks ", components); + fprintbf(cpp, "C%d::hooks ([](){\n", components); + fprintbf(cpp, "\t\tC%d::Hooks r;\n", components); auto addHook = [&](const std::string & name, const char * element, const Slice::TypePtr & t) { fprintbf(cpp, "\t\t"); - fprintbf(cpp, "C%d::addHook< C%d::Hook< const %s, ", - components, components, - Slice::typeToString(t)); + fprintbf(cpp, "C%d::addHook< C%d::Hook< const %s, ", components, components, Slice::typeToString(t)); createNewModelPartPtrFor(t); - fprintbf(cpp, " > >(r, &%s::value_type::%s, \"%s\");\n", - d->scoped(), - element, - name); + fprintbf(cpp, " > >(r, &%s::value_type::%s, \"%s\");\n", d->scoped(), element, name); }; addHook(metaDataValue("slicer:key:", d->getMetaData()).value_or("key"), "first", d->keyType()); addHook(metaDataValue("slicer:value:", d->getMetaData()).value_or("value"), "second", d->valueType()); @@ -420,8 +428,7 @@ namespace Slicer { auto name = metaDataValue("slicer:root:", d->getMetaData()); defineRoot(d->scoped(), name ? *name : d->name(), d); - fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForDictionary< %s >::metadata ", - d->scoped()); + fprintbf(cpp, "template<> DLL_PUBLIC\nconst Metadata ModelPartForDictionary< %s >::metadata ", d->scoped()); copyMetadata(d->getMetaData()); fprintbf(cpp, ";\n\n"); @@ -442,41 +449,37 @@ namespace Slicer { } void - Slicer::createModelPartForConverted(const Slice::TypePtr & type, const std::string & container, const Slice::DataMemberPtr & dm) const + Slicer::createModelPartForConverted( + const Slice::TypePtr & type, const std::string & container, const Slice::DataMemberPtr & dm) const { fprintbf(cpp, "ModelPartForConverted< "); if (dm->optional()) { - fprintbf(cpp, "Ice::optional< %s >", - Slice::typeToString(type)); + fprintbf(cpp, "Ice::optional< %s >", Slice::typeToString(type)); } else { - fprintbf(cpp, "%s", - Slice::typeToString(type)); + fprintbf(cpp, "%s", Slice::typeToString(type)); } - fprintbf(cpp, ", %s, &%s >", - container, - dm->scoped()); + fprintbf(cpp, ", %s, &%s >", container, dm->scoped()); } void - Slicer::createNewModelPartPtrFor(const Slice::TypePtr & type, const Slice::DataMemberPtr & dm, const Slice::StringList & md) const + Slicer::createNewModelPartPtrFor( + const Slice::TypePtr & type, const Slice::DataMemberPtr & dm, const Slice::StringList & md) const { auto conversions = getConversions(md); if (dm && !conversions.empty()) { - createModelPartForConverted(type, - boost::algorithm::trim_right_copy_if(dm->container()->thisScope(), ispunct), - dm); + createModelPartForConverted( + type, boost::algorithm::trim_right_copy_if(dm->container()->thisScope(), ispunct), dm); } else if (auto cmp = metaDataValue("slicer:custommodelpart:", md)) { - fprintbf(cpp, "%s", - boost::algorithm::replace_all_copy(*cmp, ".", "::")); + fprintbf(cpp, "%s", boost::algorithm::replace_all_copy(*cmp, ".", "::")); } else { if (dm && dm->optional()) { fprintbf(cpp, "ModelPartForOptional< "); } - fprintbf(cpp, "%s< %s >", - getBasicModelPart(type), Slice::ClassDeclPtr::dynamicCast(type) ? type->typeId() : Slice::typeToString(type)); + fprintbf(cpp, "%s< %s >", getBasicModelPart(type), + Slice::ClassDeclPtr::dynamicCast(type) ? type->typeId() : Slice::typeToString(type)); if (dm && dm->optional()) { fprintbf(cpp, " > "); } @@ -486,24 +489,17 @@ namespace Slicer { std::string Slicer::getBasicModelPart(const Slice::TypePtr & type) const { - if (auto builtin = Slice::BuiltinPtr::dynamicCast(type)) { - return "ModelPartForSimple"; - } - else if (auto complexClass = Slice::ClassDeclPtr::dynamicCast(type)) { - return "ModelPartForClass"; - } - else if (auto complexStruct = Slice::StructPtr::dynamicCast(type)) { - return "ModelPartForStruct"; - } - else if (auto sequence = Slice::SequencePtr::dynamicCast(type)) { - return "ModelPartForSequence"; - } - else if (auto dictionary = Slice::DictionaryPtr::dynamicCast(type)) { - return "ModelPartForDictionary"; - } - else if (auto enumeration = Slice::EnumPtr::dynamicCast(type)) { - return "ModelPartForEnum"; - } +#define CheckTypeAndReturn(Type, ModerlPartClass) \ + if (Type::dynamicCast(type)) { \ + return ModerlPartClass; \ + } + CheckTypeAndReturn(Slice::BuiltinPtr, "ModelPartForSimple"); + CheckTypeAndReturn(Slice::ClassDeclPtr, "ModelPartForClass"); + CheckTypeAndReturn(Slice::StructPtr, "ModelPartForStruct"); + CheckTypeAndReturn(Slice::SequencePtr, "ModelPartForSequence"); + CheckTypeAndReturn(Slice::DictionaryPtr, "ModelPartForDictionary"); + CheckTypeAndReturn(Slice::EnumPtr, "ModelPartForEnum"); +#undef CheckTypeAndReturn throw CompilerError("Unknown basic type"); } @@ -568,14 +564,12 @@ namespace Slicer { void Slicer::defineMODELPART(const std::string & type, const Slice::TypePtr & stype, const Slice::StringList & metadata) { - fprintbf(cpp, "// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)\n"); if (auto cmp = metaDataValue("slicer:custommodelpart:", metadata)) { - fprintbf(cpp, "CUSTOMMODELPARTFOR(%s, %s< %s >, %s);\n\n", - type, getBasicModelPart(stype), type, boost::algorithm::replace_all_copy(*cmp, ".", "::")); + fprintbf(cpp, "CUSTOMMODELPARTFOR(%s, %s< %s >, %s);\n\n", type, getBasicModelPart(stype), type, + boost::algorithm::replace_all_copy(*cmp, ".", "::")); } else { - fprintbf(cpp, "MODELPARTFOR(%s, %s);\n\n", - type, getBasicModelPart(stype)); + fprintbf(cpp, "MODELPARTFOR(%s, %s);\n\n", type, getBasicModelPart(stype)); } definedTypes.insert(stype->typeId()); } @@ -593,8 +587,7 @@ namespace Slicer { throw CompilerError("Both file handle and path provided."); } auto cppfile = std::unique_ptr<FILE, decltype(&fclose)>( - cpp || cppPath.empty() ? cpp : fopen(cppPath.c_str(), "w"), - cppPath.empty() ? fflush : fclose); + cpp || cppPath.empty() ? cpp : fopen(cppPath.c_str(), "w"), cppPath.empty() ? fflush : fclose); if (!cppfile && !cppPath.empty()) { throw CompilerError("Failed to open output file"); } @@ -602,7 +595,7 @@ namespace Slicer { cpp = cppfile.get(); Slicer::Slicer::Args args; // Copy includes to args - for(const auto & include : includes) { + for (const auto & include : includes) { args.push_back("-I" + include.string()); } @@ -646,13 +639,11 @@ namespace Slicer { } Slicer::ConversionSpec::ConversionSpec(const Slicer::Args & s) : - ExchangeType(s[0]), - ConvertToModelFunc(s[1]), - ConvertToExchangeFunc(s[2]) + ExchangeType(s[0]), ConvertToModelFunc(s[1]), ConvertToExchangeFunc(s[2]) { if (s.size() >= 4) { - boost::algorithm::split(Options, s[3], boost::algorithm::is_any_of(","), boost::algorithm::token_compress_off); + boost::algorithm::split( + Options, s[3], boost::algorithm::is_any_of(","), boost::algorithm::token_compress_off); } } }; - diff --git a/slicer/tool/parser.h b/slicer/tool/parser.h index 67aa243..295705d 100644 --- a/slicer/tool/parser.h +++ b/slicer/tool/parser.h @@ -7,81 +7,75 @@ namespace Slicer { class DLL_PUBLIC Slicer : public Slice::ParserVisitor { + public: + typedef std::vector<std::string> Args; + class ConversionSpec { public: - typedef std::vector<std::string> Args; - class ConversionSpec { - public: - explicit ConversionSpec(const Args &); - - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - std::string ExchangeType; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - std::string ConvertToModelFunc; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - std::string ConvertToExchangeFunc; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - Args Options; - }; - using Conversions = std::vector<ConversionSpec>; - - Slicer(); - - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - FILE * cpp; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - std::filesystem::path slicePath; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - std::filesystem::path cppPath; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - std::filesystem::path headerPrefix; - // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - std::vector<std::filesystem::path> includes; - - unsigned int Execute(); - [[nodiscard]] unsigned int Components() const; + explicit ConversionSpec(const Args &); + + std::string ExchangeType; + std::string ConvertToModelFunc; + std::string ConvertToExchangeFunc; + Args Options; + }; + using Conversions = std::vector<ConversionSpec>; + + Slicer(); + + FILE * cpp; + std::filesystem::path slicePath; + std::filesystem::path cppPath; + std::filesystem::path headerPrefix; + std::vector<std::filesystem::path> includes; + + unsigned int Execute(); + [[nodiscard]] unsigned int Components() const; #pragma GCC visibility push(hidden) - bool visitUnitStart(const Slice::UnitPtr&) override; + bool visitUnitStart(const Slice::UnitPtr &) override; - void visitUnitEnd(const Slice::UnitPtr&) override; + void visitUnitEnd(const Slice::UnitPtr &) override; - bool visitModuleStart(const Slice::ModulePtr & m) override; + bool visitModuleStart(const Slice::ModulePtr & m) override; - bool visitClassDefStart(const Slice::ClassDefPtr & c) override; + bool visitClassDefStart(const Slice::ClassDefPtr & c) override; - bool visitStructStart(const Slice::StructPtr&) override; + bool visitStructStart(const Slice::StructPtr &) override; - void visitEnum(const Slice::EnumPtr &) override; + void visitEnum(const Slice::EnumPtr &) override; - void visitSequence(const Slice::SequencePtr & s) override; + void visitSequence(const Slice::SequencePtr & s) override; - void visitDictionary(const Slice::DictionaryPtr & d) override; + void visitDictionary(const Slice::DictionaryPtr & d) override; - void visitModuleEnd(const Slice::ModulePtr & m) override; + void visitModuleEnd(const Slice::ModulePtr & m) override; - private: - void createModelPartForConverted(const Slice::TypePtr & type, const std::string & container, const Slice::DataMemberPtr & dm) const; - void createNewModelPartPtrFor(const Slice::TypePtr & type, const Slice::DataMemberPtr & dm = Slice::DataMemberPtr(), const Slice::StringList & md = Slice::StringList()) const; - [[nodiscard]] std::string getBasicModelPart(const Slice::TypePtr & type) const; - void defineMODELPART(const std::string & type, const Slice::TypePtr & stype, const Slice::StringList & metadata); + private: + void createModelPartForConverted( + const Slice::TypePtr & type, const std::string & container, const Slice::DataMemberPtr & dm) const; + void createNewModelPartPtrFor(const Slice::TypePtr & type, + const Slice::DataMemberPtr & dm = Slice::DataMemberPtr(), + const Slice::StringList & md = Slice::StringList()) const; + [[nodiscard]] std::string getBasicModelPart(const Slice::TypePtr & type) const; + void defineMODELPART( + const std::string & type, const Slice::TypePtr & stype, const Slice::StringList & metadata); - void visitComplexDataMembers(const Slice::ConstructedPtr & t, const Slice::DataMemberList &) const; + void visitComplexDataMembers(const Slice::ConstructedPtr & t, const Slice::DataMemberList &) const; - void defineConversions(const Slice::DataMemberPtr & dm) const; - void defineRoot(const std::string & type, const std::string & name, const Slice::TypePtr & stype) const; - void externType(const Slice::TypePtr &) const; + void defineConversions(const Slice::DataMemberPtr & dm) const; + void defineRoot(const std::string & type, const std::string & name, const Slice::TypePtr & stype) const; + void externType(const Slice::TypePtr &) const; - [[nodiscard]] bool hasMetadata(const std::list<std::string> & metadata) const; - void copyMetadata(const std::list<std::string> & metadata) const; - static Slice::StringList getAllMetadata(const Slice::DataMemberPtr & dm); - static Conversions getConversions(const Slice::StringList & metadata); - std::set<std::string> definedTypes; + [[nodiscard]] bool hasMetadata(const std::list<std::string> & metadata) const; + void copyMetadata(const std::list<std::string> & metadata) const; + static Slice::StringList getAllMetadata(const Slice::DataMemberPtr & dm); + static Conversions getConversions(const Slice::StringList & metadata); + std::set<std::string> definedTypes; #pragma GCC visibility pop - unsigned int components; - unsigned int classNo; + unsigned int components; + unsigned int classNo; }; } #endif - diff --git a/slicer/tool/slicer.cpp b/slicer/tool/slicer.cpp index 49d52a6..0145d15 100644 --- a/slicer/tool/slicer.cpp +++ b/slicer/tool/slicer.cpp @@ -1,5 +1,5 @@ -#include <tool/parser.h> #include <boost/program_options.hpp> +#include <tool/parser.h> namespace po = boost::program_options; @@ -9,6 +9,7 @@ main(int argc, char ** argv) Slicer::Slicer slicer; po::options_description opts("Slicer options"); + // clang-format off opts.add_options() ("help,h", "Show this help message") ("include,I", po::value(&slicer.includes), "Add include directory to search path") @@ -16,6 +17,7 @@ main(int argc, char ** argv) ("headerPrefix", po::value(&slicer.headerPrefix)->default_value(slicer.headerPrefix), "Prefix path for Slicer C++ #includes") ("slice,i", po::value(&slicer.slicePath), "Input ICE Slice file") ("cpp,o", po::value(&slicer.cppPath), "Output C++ file"); + // clang-format on po::positional_options_description p; p.add("slice", 1); @@ -35,4 +37,3 @@ main(int argc, char ** argv) return 0; } - diff --git a/slicer/xml/Jamfile.jam b/slicer/xml/Jamfile.jam index c237f93..4150632 100644 --- a/slicer/xml/Jamfile.jam +++ b/slicer/xml/Jamfile.jam @@ -15,7 +15,6 @@ lib slicer-xml : <library>../slicer//slicer <implicit-dependency>../slicer//slicer <implicit-dependency>xmlExceptions - <toolset>tidy:<xcheckxx>clang-analyzer-optin.cplusplus.VirtualCall : : <library>../..//libxmlpp <implicit-dependency>xmlExceptions diff --git a/slicer/xml/serializer.cpp b/slicer/xml/serializer.cpp index f31acb0..fbda026 100644 --- a/slicer/xml/serializer.cpp +++ b/slicer/xml/serializer.cpp @@ -1,13 +1,13 @@ #include "serializer.h" -#include <xmlExceptions.h> -#include <slicer/metadata.h> -#include <libxml++/document.h> -#include <libxml++/parsers/domparser.h> #include <boost/lexical_cast.hpp> +#include <compileTimeFormatter.h> #include <functional> -#include <stdexcept> #include <glibmm/ustring.h> -#include <compileTimeFormatter.h> +#include <libxml++/document.h> +#include <libxml++/parsers/domparser.h> +#include <slicer/metadata.h> +#include <stdexcept> +#include <xmlExceptions.h> NAMEDFACTORY(".xml", Slicer::XmlFileSerializer, Slicer::FileSerializerFactory); NAMEDFACTORY(".xml", Slicer::XmlFileDeserializer, Slicer::FileDeserializerFactory); @@ -24,169 +24,180 @@ namespace Slicer { const std::string md_elements = "xml:elements"; const std::string keyName = "key"; const std::string valueName = "value"; - using ElementCreatorF = xmlpp::Element * (xmlpp::Element::*) (const Glib::ustring &, const Glib::ustring &); - const auto defaultElementCreator = std::bind((ElementCreatorF)&xmlpp::Element::add_child_element, _1, _2, Glib::ustring()); + using ElementCreatorF = xmlpp::Element * (xmlpp::Element::*)(const Glib::ustring &, const Glib::ustring &); + const auto defaultElementCreator = [](auto && element, auto && name) { + return element->add_child_element(name); + }; static const Glib::ustring TrueText("true"); static const Glib::ustring FalseText("false"); class XmlValueSource : public ValueSource { - public: - explicit XmlValueSource(Glib::ustring s) : - value(std::move(s)) - { - } + public: + explicit XmlValueSource(Glib::ustring s) : value(std::move(s)) { } - void set(bool & v) const override - { - if (value == TrueText) { v = true; return; } - if (value == FalseText) { v = false; return; } - throw BadBooleanValue(value); + void + set(bool & v) const override + { + if (value == TrueText) { + v = true; + return; } - - void set(Ice::Byte & v) const override - { - v = boost::numeric_cast<Ice::Byte>(boost::lexical_cast<int>(value)); + if (value == FalseText) { + v = false; + return; } + throw BadBooleanValue(value); + } - void set(Ice::Short & v) const override - { - v = boost::lexical_cast<Ice::Short>(value); - } + void + set(Ice::Byte & v) const override + { + v = boost::numeric_cast<Ice::Byte>(boost::lexical_cast<int>(value)); + } - void set(Ice::Int & v) const override - { - v = boost::lexical_cast<Ice::Int>(value); - } + void + set(Ice::Short & v) const override + { + v = boost::lexical_cast<Ice::Short>(value); + } - void set(Ice::Long & v) const override - { - v = boost::lexical_cast<Ice::Long>(value); - } + void + set(Ice::Int & v) const override + { + v = boost::lexical_cast<Ice::Int>(value); + } - void set(Ice::Float & v) const override - { - v = boost::lexical_cast<Ice::Float>(value); - } + void + set(Ice::Long & v) const override + { + v = boost::lexical_cast<Ice::Long>(value); + } - void set(Ice::Double & v) const override - { - v = boost::lexical_cast<Ice::Double>(value); - } + void + set(Ice::Float & v) const override + { + v = boost::lexical_cast<Ice::Float>(value); + } - void set(std::string & v) const override - { - v = value.raw(); - } + void + set(Ice::Double & v) const override + { + v = boost::lexical_cast<Ice::Double>(value); + } + + void + set(std::string & v) const override + { + v = value.raw(); + } - private: - const Glib::ustring value; + private: + const Glib::ustring value; }; class XmlContentValueSource : public XmlValueSource { - public: - explicit XmlContentValueSource() : - XmlValueSource(Glib::ustring()) - { - } - explicit XmlContentValueSource(const xmlpp::ContentNode * c) : - XmlValueSource(c->get_content()) - { - } + public: + explicit XmlContentValueSource() : XmlValueSource(Glib::ustring()) { } + explicit XmlContentValueSource(const xmlpp::ContentNode * c) : XmlValueSource(c->get_content()) { } }; class XmlAttributeValueSource : public XmlValueSource { - public: - explicit XmlAttributeValueSource(const xmlpp::Attribute * a) : - XmlValueSource(a->get_value()) - { - } + public: + explicit XmlAttributeValueSource(const xmlpp::Attribute * a) : XmlValueSource(a->get_value()) { } }; class XmlValueTarget : public ValueTarget { - public: - explicit XmlValueTarget(std::function<void(const Glib::ustring &)> a) : - apply(std::move(a)) - { - } + public: + explicit XmlValueTarget(std::function<void(const Glib::ustring &)> a) : apply(std::move(a)) { } - void get(const bool & value) const override - { - if (value) { - apply(TrueText); - } - else { - apply(FalseText); - } + void + get(const bool & value) const override + { + if (value) { + apply(TrueText); } - - void get(const Ice::Byte & value) const override - { - apply(boost::lexical_cast<Glib::ustring>((int)value)); + else { + apply(FalseText); } + } - void get(const Ice::Short & value) const override - { - apply(boost::lexical_cast<Glib::ustring>(value)); - } + void + get(const Ice::Byte & value) const override + { + apply(boost::lexical_cast<Glib::ustring>((int)value)); + } - void get(const Ice::Int & value) const override - { - apply(boost::lexical_cast<Glib::ustring>(value)); - } + void + get(const Ice::Short & value) const override + { + apply(boost::lexical_cast<Glib::ustring>(value)); + } - void get(const Ice::Long & value) const override - { - apply(boost::lexical_cast<Glib::ustring>(value)); - } + void + get(const Ice::Int & value) const override + { + apply(boost::lexical_cast<Glib::ustring>(value)); + } - void get(const Ice::Float & value) const override - { - apply(boost::lexical_cast<Glib::ustring>(value)); - } + void + get(const Ice::Long & value) const override + { + apply(boost::lexical_cast<Glib::ustring>(value)); + } - void get(const Ice::Double & value) const override - { - apply(boost::lexical_cast<Glib::ustring>(value)); - } + void + get(const Ice::Float & value) const override + { + apply(boost::lexical_cast<Glib::ustring>(value)); + } - void get(const std::string & value) const override - { - apply(value); - } + void + get(const Ice::Double & value) const override + { + apply(boost::lexical_cast<Glib::ustring>(value)); + } - private: - const std::function<void(const Glib::ustring &)> apply; - }; + void + get(const std::string & value) const override + { + apply(value); + } + private: + const std::function<void(const Glib::ustring &)> apply; + }; class XmlAttributeValueTarget : public XmlValueTarget { - public: - explicit XmlAttributeValueTarget(xmlpp::Element * p, const std::string & n) : - XmlValueTarget([p, n](auto && PH1) { - p->set_attribute(n, PH1); - }) - { - } + public: + explicit XmlAttributeValueTarget(xmlpp::Element * p, const std::string & n) : + XmlValueTarget([p, n](auto && PH1) { + p->set_attribute(n, PH1); + }) + { + } }; class XmlContentValueTarget : public XmlValueTarget { - public: - explicit XmlContentValueTarget(xmlpp::Element * p) : - XmlValueTarget([p](auto && PH1) { - p->set_first_child_text(PH1); - }) - { - } + public: + explicit XmlContentValueTarget(xmlpp::Element * p) : + XmlValueTarget([p](auto && PH1) { + p->set_first_child_text(PH1); + }) + { + } - explicit XmlContentValueTarget(const CurrentElementCreator & cec) : - XmlValueTarget(std::bind(&xmlpp::Element::set_first_child_text, std::bind(&CurrentElementCreator::deref, &cec), _1)) - { - } + explicit XmlContentValueTarget(const CurrentElementCreator & cec) : + XmlValueTarget([&](auto && PH1) { + cec->set_first_child_text(PH1); + }) + { + } }; void - XmlDeserializer::DocumentTreeIterateDictAttrs(const xmlpp::Element::const_AttributeList & attrs, const ModelPartPtr & dict) + XmlDeserializer::DocumentTreeIterateDictAttrs( + const xmlpp::Element::const_AttributeList & attrs, const ModelPartPtr & dict) { for (const auto & attr : attrs) { auto emp = dict->GetAnonChild(); @@ -307,7 +318,8 @@ namespace Slicer { } void - XmlSerializer::ModelTreeIterate(xmlpp::Element * n, const std::string & name, const ModelPartPtr & mp, const HookCommon * hp, const ElementCreator & ec) + XmlSerializer::ModelTreeIterate(xmlpp::Element * n, const std::string & name, const ModelPartPtr & mp, + const HookCommon * hp, const ElementCreator & ec) { if (name.empty()) { return; @@ -331,7 +343,9 @@ namespace Slicer { }); } else { - CurrentElementCreator cec([ec, n, name] { return ec(n, name); }); + CurrentElementCreator cec([ec, n, name] { + return ec(n, name); + }); ModelTreeProcessElement(cec, mp, defaultElementCreator); } } @@ -342,7 +356,7 @@ namespace Slicer { { dict->OnEachChild([element](const auto &, const auto & mp, const auto &) { if (mp->HasValue()) { - mp->GetChild(keyName)->GetValue(XmlValueTarget([&mp,element](const auto & name) { + mp->GetChild(keyName)->GetValue(XmlValueTarget([&mp, element](const auto & name) { mp->GetChild(valueName)->GetValue(XmlAttributeValueTarget(element, name)); })); } @@ -354,8 +368,10 @@ namespace Slicer { { dict->OnEachChild([element](const auto &, const auto & mp, const auto &) { if (mp->HasValue()) { - mp->GetChild(keyName)->GetValue(XmlValueTarget([&mp,element](const auto & name) { - CurrentElementCreator cec([&element, &name]() { return element->add_child_element(name); }); + mp->GetChild(keyName)->GetValue(XmlValueTarget([&mp, element](const auto & name) { + CurrentElementCreator cec([&element, &name]() { + return element->add_child_element(name); + }); ModelTreeProcessElement(cec, mp->GetChild(valueName), defaultElementCreator); })); } @@ -363,9 +379,10 @@ namespace Slicer { } void - XmlSerializer::ModelTreeProcessElement(const CurrentElementCreator & cec, ModelPartPtr mp, const ElementCreator & ec) + XmlSerializer::ModelTreeProcessElement( + const CurrentElementCreator & cec, ModelPartPtr mp, const ElementCreator & ec) { - if (mp->GetType() == mpt_Simple) { + if (mp->GetType() == ModelPartType::Simple) { mp->GetValue(XmlContentValueTarget(cec)); } else if (mp->HasValue()) { @@ -388,15 +405,9 @@ namespace Slicer { ModelTreeProcessElement(doc->create_root_node(name), mp, defaultElementCreator); } - XmlStreamSerializer::XmlStreamSerializer(std::ostream & s) : - strm(s) - { - } + XmlStreamSerializer::XmlStreamSerializer(std::ostream & s) : strm(s) { } - XmlStreamDeserializer::XmlStreamDeserializer(std::istream & s) : - strm(s) - { - } + XmlStreamDeserializer::XmlStreamDeserializer(std::istream & s) : strm(s) { } void XmlStreamDeserializer::Deserialize(ModelPartForRootPtr modelRoot) @@ -417,15 +428,9 @@ namespace Slicer { doc.write_to_stream(strm); } - XmlFileSerializer::XmlFileSerializer(std::filesystem::path p) : - path(std::move(p)) - { - } + XmlFileSerializer::XmlFileSerializer(std::filesystem::path p) : path(std::move(p)) { } - XmlFileDeserializer::XmlFileDeserializer(std::filesystem::path p) : - path(std::move(p)) - { - } + XmlFileDeserializer::XmlFileDeserializer(std::filesystem::path p) : path(std::move(p)) { } void XmlFileDeserializer::Deserialize(ModelPartForRootPtr modelRoot) @@ -445,15 +450,9 @@ namespace Slicer { doc.write_to_file_formatted(path); } - XmlDocumentSerializer::XmlDocumentSerializer(xmlpp::Document * & d) : - doc(d) - { - } + XmlDocumentSerializer::XmlDocumentSerializer(xmlpp::Document *& d) : doc(d) { } - XmlDocumentDeserializer::XmlDocumentDeserializer(const xmlpp::Document * d) : - doc(d) - { - } + XmlDocumentDeserializer::XmlDocumentDeserializer(const xmlpp::Document * d) : doc(d) { } void XmlDocumentDeserializer::Deserialize(ModelPartForRootPtr modelRoot) @@ -471,9 +470,9 @@ namespace Slicer { } AdHocFormatter(BadBooleanValueMsg, "Bad boolean value [%?]"); - void BadBooleanValue::ice_print(std::ostream & s) const + void + BadBooleanValue::ice_print(std::ostream & s) const { BadBooleanValueMsg::write(s, text); } } - diff --git a/slicer/xml/serializer.h b/slicer/xml/serializer.h index f41e5a7..99b03dd 100644 --- a/slicer/xml/serializer.h +++ b/slicer/xml/serializer.h @@ -1,96 +1,97 @@ #ifndef SLICER_XML_H #define SLICER_XML_H -#include <slicer/serializer.h> +#include <lazyPointer.h> #include <libxml++/document.h> #include <libxml++/nodes/element.h> +#include <slicer/serializer.h> #include <visibility.h> -#include <lazyPointer.h> namespace Slicer { - typedef ::AdHoc::LazyPointer<xmlpp::Element, xmlpp::Element *> CurrentElementCreator; + using CurrentElementCreator = ::AdHoc::LazyPointer<xmlpp::Element, xmlpp::Element *>; class DLL_PUBLIC XmlSerializer : public Serializer { - protected: - typedef std::function<xmlpp::Element *(xmlpp::Element *, const Glib::ustring &)> ElementCreator; - static void ModelTreeIterate(xmlpp::Element *, const std::string &, const ModelPartPtr & mp, const HookCommon * hp, const ElementCreator &); - static void ModelTreeIterateRoot(xmlpp::Document *, const std::string &, const ModelPartPtr & mp); - - protected: - static void ModelTreeProcessElement(const CurrentElementCreator &, ModelPartPtr mp, const ElementCreator &); - static void ModelTreeIterateDictAttrs(xmlpp::Element * element, const ModelPartPtr & dict); - static void ModelTreeIterateDictElements(xmlpp::Element * element, const ModelPartPtr & dict); + protected: + using ElementCreator = std::function<xmlpp::Element *(xmlpp::Element *, const Glib::ustring &)>; + static void ModelTreeIterate(xmlpp::Element *, const std::string &, const ModelPartPtr & mp, + const HookCommon * hp, const ElementCreator &); + static void ModelTreeIterateRoot(xmlpp::Document *, const std::string &, const ModelPartPtr & mp); + + protected: + static void ModelTreeProcessElement(const CurrentElementCreator &, ModelPartPtr mp, const ElementCreator &); + static void ModelTreeIterateDictAttrs(xmlpp::Element * element, const ModelPartPtr & dict); + static void ModelTreeIterateDictElements(xmlpp::Element * element, const ModelPartPtr & dict); }; class DLL_PUBLIC XmlStreamSerializer : public XmlSerializer { - public: - XmlStreamSerializer(std::ostream &); + public: + explicit XmlStreamSerializer(std::ostream &); - void Serialize(ModelPartForRootPtr) override; + void Serialize(ModelPartForRootPtr) override; - protected: - std::ostream & strm; + protected: + std::ostream & strm; }; class DLL_PUBLIC XmlFileSerializer : public XmlSerializer { - public: - XmlFileSerializer(std::filesystem::path); + public: + explicit XmlFileSerializer(std::filesystem::path); - void Serialize(ModelPartForRootPtr) override; + void Serialize(ModelPartForRootPtr) override; - protected: - const std::filesystem::path path; + protected: + const std::filesystem::path path; }; class DLL_PUBLIC XmlDocumentSerializer : public XmlSerializer { - public: - XmlDocumentSerializer(xmlpp::Document * &); + public: + explicit XmlDocumentSerializer(xmlpp::Document *&); - void Serialize(ModelPartForRootPtr) override; + void Serialize(ModelPartForRootPtr) override; - protected: - xmlpp::Document * & doc; + protected: + xmlpp::Document *& doc; }; class DLL_PUBLIC XmlDeserializer : public Deserializer { - protected: - static void DocumentTreeIterate(const xmlpp::Node * node, const ModelPartPtr & mp); - static void DocumentTreeIterateElement(const xmlpp::Element * element, ModelPartPtr mp, const ChildRef & c); - static void DocumentTreeIterate(const xmlpp::Document * doc, const ModelPartPtr & mp); - static void DocumentTreeIterateDictAttrs(const xmlpp::Element::const_AttributeList & attrs, const ModelPartPtr & dict); - static void DocumentTreeIterateDictElements(const xmlpp::Element * parent, const ModelPartPtr & dict); + protected: + static void DocumentTreeIterate(const xmlpp::Node * node, const ModelPartPtr & mp); + static void DocumentTreeIterateElement(const xmlpp::Element * element, ModelPartPtr mp, const ChildRef & c); + static void DocumentTreeIterate(const xmlpp::Document * doc, const ModelPartPtr & mp); + static void DocumentTreeIterateDictAttrs( + const xmlpp::Element::const_AttributeList & attrs, const ModelPartPtr & dict); + static void DocumentTreeIterateDictElements(const xmlpp::Element * parent, const ModelPartPtr & dict); }; class DLL_PUBLIC XmlStreamDeserializer : public XmlDeserializer { - public: - XmlStreamDeserializer(std::istream &); + public: + explicit XmlStreamDeserializer(std::istream &); - void Deserialize(ModelPartForRootPtr) override; + void Deserialize(ModelPartForRootPtr) override; - protected: - std::istream & strm; + protected: + std::istream & strm; }; class DLL_PUBLIC XmlFileDeserializer : public XmlDeserializer { - public: - XmlFileDeserializer(std::filesystem::path); + public: + explicit XmlFileDeserializer(std::filesystem::path); - void Deserialize(ModelPartForRootPtr) override; + void Deserialize(ModelPartForRootPtr) override; - protected: - const std::filesystem::path path; + protected: + const std::filesystem::path path; }; class DLL_PUBLIC XmlDocumentDeserializer : public XmlDeserializer { - public: - XmlDocumentDeserializer(const xmlpp::Document *); + public: + explicit XmlDocumentDeserializer(const xmlpp::Document *); - void Deserialize(ModelPartForRootPtr) override; + void Deserialize(ModelPartForRootPtr) override; - protected: - const xmlpp::Document * doc; + protected: + const xmlpp::Document * doc; }; } #endif - diff --git a/slicer/xml/testSpecifics.cpp b/slicer/xml/testSpecifics.cpp index d20ea09..3d05979 100644 --- a/slicer/xml/testSpecifics.cpp +++ b/slicer/xml/testSpecifics.cpp @@ -1,19 +1,19 @@ #define BOOST_TEST_MODULE xml_specifics -#include <boost/test/unit_test.hpp> -#include <slicer/slicer.h> #include "serializer.h" +#include <boost/test/unit_test.hpp> #include <libxml++/parsers/domparser.h> +#include <slicer/slicer.h> #include <types.h> #include <xmlExceptions.h> -template <typename T, typename ... P> +template<typename T, typename... P> T -BoostThrowWrapperHelper(P && ... p) +BoostThrowWrapperHelper(P &&... p) { return Slicer::DeserializeAny<Slicer::XmlDocumentDeserializer, T>(p...); } -BOOST_AUTO_TEST_CASE( boolean_values ) +BOOST_AUTO_TEST_CASE(boolean_values) { xmlpp::DomParser doc; doc.parse_memory("<Boolean>true</Boolean>"); @@ -28,7 +28,7 @@ BOOST_AUTO_TEST_CASE( boolean_values ) BOOST_REQUIRE_THROW(BoostThrowWrapperHelper<bool>(doc.get_document()), Slicer::BadBooleanValue); } -BOOST_AUTO_TEST_CASE( int_values ) +BOOST_AUTO_TEST_CASE(int_values) { xmlpp::DomParser doc; doc.parse_memory("<Int>13</Int>"); @@ -47,11 +47,10 @@ BOOST_AUTO_TEST_CASE( int_values ) BOOST_REQUIRE_THROW(BoostThrowWrapperHelper<Ice::Int>(doc.get_document()), std::bad_cast); } -BOOST_AUTO_TEST_CASE( factories ) +BOOST_AUTO_TEST_CASE(factories) { BOOST_REQUIRE(Slicer::SerializerPtr(Slicer::FileSerializerFactory::createNew(".xml", "/some.xml"))); BOOST_REQUIRE(Slicer::DeserializerPtr(Slicer::FileDeserializerFactory::createNew(".xml", "/some.xml"))); BOOST_REQUIRE(Slicer::SerializerPtr(Slicer::StreamSerializerFactory::createNew("application/xml", std::cout))); BOOST_REQUIRE(Slicer::DeserializerPtr(Slicer::StreamDeserializerFactory::createNew("application/xml", std::cin))); } - |