Apply clang-format

generator/binaryserializationcodegenerator.cpp

@@ -45,8 +45,7 @@ string BinarySerializationCodeGenerator::qualifiedNameIfRelevant(clang::CXXRecor
         return qualifiedName;
     case IsRelevant::No:
         return string();
-    default:
+    default:;
-        ;
     }
 
     // consider all classes specified via "--additional-classes" argument relevant
@@ -119,7 +118,8 @@ void BinarySerializationCodeGenerator::generate(ostream &os) const
 
         // print writeCustomType method
         os << "template <> " << visibility << " void writeCustomType<::" << relevantClass.qualifiedName
-           << ">(BinarySerializer &serializer, const ::" << relevantClass.qualifiedName << " &customObject)\n{\n"
+           << ">(BinarySerializer &serializer, const ::" << relevantClass.qualifiedName
+           << " &customObject)\n{\n"
               "    // write base classes\n";
         for (const RelevantClass *baseClass : relevantBases) {
             os << "    serializer.write(static_cast<const ::" << baseClass->qualifiedName << " &>(customObject));\n";
@@ -139,7 +139,8 @@ void BinarySerializationCodeGenerator::generate(ostream &os) const
 
         // print readCustomType method
         os << "template <> " << visibility << " void readCustomType<::" << relevantClass.qualifiedName
-           << ">(BinaryDeserializer &deserializer, ::" << relevantClass.qualifiedName << " &customObject)\n{\n"
+           << ">(BinaryDeserializer &deserializer, ::" << relevantClass.qualifiedName
+           << " &customObject)\n{\n"
               "    // read base classes\n";
         for (const RelevantClass *baseClass : relevantBases) {
             os << "    deserializer.read(static_cast<::" << baseClass->qualifiedName << " &>(customObject));\n";

generator/jsonserializationcodegenerator.cpp

@@ -45,8 +45,7 @@ string JsonSerializationCodeGenerator::qualifiedNameIfRelevant(clang::CXXRecordD
         return qualifiedName;
     case IsRelevant::No:
         return string();
-    default:
+    default:;
-        ;
     }
 
     // consider all classes specified via "--additional-classes" argument relevant

generator/main.cpp

@@ -1,6 +1,6 @@
+#include "./binaryserializationcodegenerator.h"
 #include "./codefactory.h"
 #include "./jsonserializationcodegenerator.h"
-#include "./binaryserializationcodegenerator.h"
 
 #include "resources/config.h"
 

generator/serializationcodegenerator.cpp

@@ -64,7 +64,8 @@ void SerializationCodeGenerator::addDeclaration(clang::Decl *decl)
     }
 }
 
-SerializationCodeGenerator::IsRelevant SerializationCodeGenerator::isQualifiedNameIfRelevant(clang::CXXRecordDecl *record, const std::string &qualifiedName) const
+SerializationCodeGenerator::IsRelevant SerializationCodeGenerator::isQualifiedNameIfRelevant(
+    clang::CXXRecordDecl *record, const std::string &qualifiedName) const
 {
     // consider all classes for which a specialization of the "AdaptedJsonSerializable" struct is available
     for (const auto &adaptionRecord : m_adaptionRecords) {
@@ -102,7 +103,8 @@ std::vector<SerializationCodeGenerator::RelevantClass> SerializationCodeGenerato
     return relevantClasses;
 }
 
-std::vector<const SerializationCodeGenerator::RelevantClass *> SerializationCodeGenerator::findRelevantBaseClasses(const SerializationCodeGenerator::RelevantClass &relevantClass, const std::vector<SerializationCodeGenerator::RelevantClass> &relevantBases)
+std::vector<const SerializationCodeGenerator::RelevantClass *> SerializationCodeGenerator::findRelevantBaseClasses(
+    const SerializationCodeGenerator::RelevantClass &relevantClass, const std::vector<SerializationCodeGenerator::RelevantClass> &relevantBases)
 {
     vector<const RelevantClass *> relevantBaseClasses;
     for (const RelevantClass &otherClass : relevantBases) {

generator/serializationcodegenerator.h

@@ -27,9 +27,7 @@ public:
     void addDeclaration(clang::Decl *decl) override;
 
 protected:
-    enum class IsRelevant {
+    enum class IsRelevant { Yes, No, Maybe };
-        Yes, No, Maybe
-    };
     IsRelevant isQualifiedNameIfRelevant(clang::CXXRecordDecl *record, const std::string &qualifiedName) const;
     virtual std::string qualifiedNameIfRelevant(clang::CXXRecordDecl *record) const = 0;
     std::vector<RelevantClass> findRelevantClasses() const;

generator/tests/morestructs.h

@@ -1,8 +1,8 @@
 #ifndef REFLECTIVE_RAPIDJSON_TESTS_MORE_STRUCTS_H
 #define REFLECTIVE_RAPIDJSON_TESTS_MORE_STRUCTS_H
 
-#include "../../lib/json/serializable.h"
 #include "../../lib/binary/serializable.h"
+#include "../../lib/json/serializable.h"
 
 using namespace std;
 using namespace ReflectiveRapidJSON;

generator/tests/structs.h

@@ -8,10 +8,10 @@
 // contained structs as well (to prevent violating the one definition rule)
 #include "./morestructs.h"
 
-#include "../../lib/json/reflector-chronoutilities.h"
-#include "../../lib/json/serializable.h"
 #include "../../lib/binary/reflector-chronoutilities.h"
 #include "../../lib/binary/serializable.h"
+#include "../../lib/json/reflector-chronoutilities.h"
+#include "../../lib/json/serializable.h"
 
 #include <deque>
 #include <list>

lib/binary/reflector-boosthana.h

@@ -24,23 +24,19 @@
 namespace ReflectiveRapidJSON {
 namespace BinaryReflector {
 
-template <typename Type, Traits::EnableIf<IsCustomType<Type>> *>
+template <typename Type, Traits::EnableIf<IsCustomType<Type>> *> void readCustomType(BinaryDeserializer &deserializer, Type &customType)
-void readCustomType(BinaryDeserializer &deserializer, Type &customType)
 {
-    boost::hana::for_each(boost::hana::keys(customType), [&deserializer, &customType](auto key) {
+    boost::hana::for_each(
-        deserializer.read(boost::hana::at_key(customType, key));
+        boost::hana::keys(customType), [&deserializer, &customType](auto key) { deserializer.read(boost::hana::at_key(customType, key)); });
-    });
 }
 
-template <typename Type, Traits::EnableIf<IsCustomType<Type>> *>
+template <typename Type, Traits::EnableIf<IsCustomType<Type>> *> void writeCustomType(BinarySerializer &serializer, const Type &customType)
-void writeCustomType(BinarySerializer &serializer, const Type &customType)
 {
-    boost::hana::for_each(boost::hana::keys(customType), [&serializer, &customType](auto key) {
+    boost::hana::for_each(
-        serializer.write(boost::hana::at_key(customType, key));
+        boost::hana::keys(customType), [&serializer, &customType](auto key) { serializer.write(boost::hana::at_key(customType, key)); });
-    });
 }
 
-} // namespace JsonReflector
+} // namespace BinaryReflector
 } // namespace ReflectiveRapidJSON
 
 #endif // REFLECTIVE_RAPIDJSON_BINARY_REFLECTOR_BOOST_HANA_H

lib/binary/serializable.h

@@ -35,8 +35,7 @@ template <typename Type> inline void BinarySerializable<Type>::restoreFromBinary
     BinaryReflector::BinaryDeserializer(&inputStream).read(static_cast<Type &>(*this));
 }
 
-template<typename Type>
+template <typename Type> Type BinarySerializable<Type>::fromBinary(std::istream &inputStream)
-Type BinarySerializable<Type>::fromBinary(std::istream &inputStream)
 {
     Type object;
     static_cast<BinarySerializable<Type> &>(object).restoreFromBinary(inputStream);