Reformat code with clang format

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CalculateSizeAndAlignPostProcessor.cpp

@@ -1,12 +1,12 @@
 #include "CalculateSizeAndAlignPostProcessor.h"
 
-#include <cassert>
-#include <iostream>
-#include <cstdint>
-
 #include "Domain/Definition/ArrayDeclarationModifier.h"
 #include "Utils/AlignmentUtils.h"
 
+#include <cassert>
+#include <cstdint>
+#include <iostream>
+
 unsigned CalculateSizeAndAlignPostProcessor::GetPointerSizeForArchitecture(const Architecture architecture)
 {
     switch (architecture)
@@ -141,7 +141,8 @@ bool CalculateSizeAndAlignPostProcessor::CalculateSize(IDataRepository* reposito
                 currentBitOffset = 0;
             }
 
-            definition->m_size = AlignmentUtils::Align(definition->m_size, member->GetForceAlignment() ? member->GetAlignment() : std::min(member->GetAlignment(), definition->m_pack));
+            definition->m_size = AlignmentUtils::Align(
+                definition->m_size, member->GetForceAlignment() ? member->GetAlignment() : std::min(member->GetAlignment(), definition->m_pack));
 
             member->m_offset = definition->m_size;
 
@@ -186,8 +187,7 @@ bool CalculateSizeAndAlignPostProcessor::CalculateFields(IDataRepository* reposi
     if (declaration->m_flags & TypeDeclaration::FLAG_FIELDS_CALCULATED)
         return true;
 
-    if(!CalculateAlign(repository, declaration)
-        || !CalculateSize(repository, declaration))
+    if (!CalculateAlign(repository, declaration) || !CalculateSize(repository, declaration))
     {
         return false;
     }
@@ -208,8 +208,7 @@ bool CalculateSizeAndAlignPostProcessor::CalculateFields(IDataRepository* reposi
 
     structDefinition->m_flags |= DefinitionWithMembers::FLAG_FIELDS_CALCULATING;
 
-    if (!CalculateAlign(repository, structDefinition)
-        || !CalculateSize(repository, structDefinition))
+    if (!CalculateAlign(repository, structDefinition) || !CalculateSize(repository, structDefinition))
     {
         return false;
     }
@@ -232,8 +231,7 @@ bool CalculateSizeAndAlignPostProcessor::CalculateFields(IDataRepository* reposi
 
     unionDefinition->m_flags |= DefinitionWithMembers::FLAG_FIELDS_CALCULATING;
 
-    if (!CalculateAlign(repository, unionDefinition)
-        || !CalculateSize(repository, unionDefinition))
+    if (!CalculateAlign(repository, unionDefinition) || !CalculateSize(repository, unionDefinition))
     {
         return false;
     }
@@ -246,19 +244,19 @@ bool CalculateSizeAndAlignPostProcessor::CalculateFields(IDataRepository* reposi
 
 bool CalculateSizeAndAlignPostProcessor::CalculateFieldsIfNecessary(IDataRepository* repository, const DataDefinition* definition)
 {
-    if(definition->GetType() == DataDefinitionType::STRUCT)
+    if (definition->GetType() == DataDefinitionType::STRUCT)
     {
         // We can do a const cast here because the only reason that field is const anyway is because it could be a base type
         return CalculateFields(repository, dynamic_cast<StructDefinition*>(const_cast<DataDefinition*>(definition)));
     }
 
-    if(definition->GetType() == DataDefinitionType::UNION)
+    if (definition->GetType() == DataDefinitionType::UNION)
     {
         // We can do a const cast here because the only reason that field is const anyway is because it could be a base type
         return CalculateFields(repository, dynamic_cast<UnionDefinition*>(const_cast<DataDefinition*>(definition)));
     }
 
-    if(definition->GetType() == DataDefinitionType::TYPEDEF)
+    if (definition->GetType() == DataDefinitionType::TYPEDEF)
     {
         // We can do a const cast here because the only reason that field is const anyway is because it could be a base type
         return CalculateFields(repository, dynamic_cast<TypedefDefinition*>(const_cast<DataDefinition*>(definition))->m_type_declaration.get());

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateMemberInformationPostProcessor.cpp

@@ -4,19 +4,19 @@
 
 bool CreateMemberInformationPostProcessor::CreateMemberInformationForStructure(IDataRepository* repository, StructureInformation* structure) const
 {
-    for(const auto& member : structure->m_definition->m_members)
+    for (const auto& member : structure->m_definition->m_members)
     {
         StructureInformation* typeInfo = nullptr;
         const auto* currentDefinition = member->m_type_declaration->m_type;
 
-        while(currentDefinition->GetType() == DataDefinitionType::TYPEDEF)
+        while (currentDefinition->GetType() == DataDefinitionType::TYPEDEF)
         {
             currentDefinition = dynamic_cast<const TypedefDefinition*>(currentDefinition)->m_type_declaration->m_type;
         }
 
         const auto* memberDefinition = dynamic_cast<const DefinitionWithMembers*>(currentDefinition);
 
-        if(memberDefinition != nullptr)
+        if (memberDefinition != nullptr)
             typeInfo = repository->GetInformationFor(memberDefinition);
 
         structure->m_ordered_members.emplace_back(std::make_unique<MemberInformation>(structure, typeInfo, member.get()));
@@ -29,8 +29,10 @@ bool CreateMemberInformationPostProcessor::PostProcess(IDataRepository* reposito
 {
     const auto& allStructureInformation = repository->GetAllStructureInformation();
 
-    return std::all_of(allStructureInformation.begin(), allStructureInformation.end(), [this, repository](StructureInformation* structure)
-    {
-        return CreateMemberInformationForStructure(repository, structure);
-    });
+    return std::all_of(allStructureInformation.begin(),
+                       allStructureInformation.end(),
+                       [this, repository](StructureInformation* structure)
+                       {
+                           return CreateMemberInformationForStructure(repository, structure);
+                       });
 }

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateStructureInformationPostProcessor.cpp

@@ -2,17 +2,17 @@
 
 bool CreateStructureInformationPostProcessor::PostProcess(IDataRepository* repository)
 {
-    for(auto* structDefinition : repository->GetAllStructs())
+    for (auto* structDefinition : repository->GetAllStructs())
     {
         auto* information = repository->GetInformationFor(structDefinition);
-        if(information == nullptr)
+        if (information == nullptr)
             repository->Add(std::make_unique<StructureInformation>(structDefinition));
     }
 
-    for(auto* unionDefinition : repository->GetAllUnions())
+    for (auto* unionDefinition : repository->GetAllUnions())
     {
         auto* information = repository->GetInformationFor(unionDefinition);
-        if(information == nullptr)
+        if (information == nullptr)
             repository->Add(std::make_unique<StructureInformation>(unionDefinition));
     }
 

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/LeafsPostProcessor.cpp

@@ -35,9 +35,7 @@ bool LeafsPostProcessor::IsLeaf(StructureInformation* info)
         if (computations.HasDynamicArraySize())
             return false;
 
-        if (member->m_type != nullptr
-            && member->m_type != info
-            && !IsLeaf(member->m_type))
+        if (member->m_type != nullptr && member->m_type != info && !IsLeaf(member->m_type))
         {
             return false;
         }

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/MemberLeafsPostProcessor.cpp

@@ -34,7 +34,7 @@ bool MemberLeafsPostProcessor::MemberIsLeaf(MemberInformation* member)
 
 void MemberLeafsPostProcessor::ProcessInfo(StructureInformation* info)
 {
-    for(const auto& member : info->m_ordered_members)
+    for (const auto& member : info->m_ordered_members)
     {
         member->m_is_leaf = MemberIsLeaf(member.get());
     }

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/UnionsPostProcessor.cpp

@@ -9,9 +9,9 @@ bool UnionsPostProcessor::ProcessUnion(StructureInformation* info)
     auto lastEntryWithoutCondition = 0u;
     auto entriesWithoutConditionCount = 0u;
 
-    for(const auto& member : info->m_ordered_members)
+    for (const auto& member : info->m_ordered_members)
     {
-        if(!member->m_condition && !member->m_is_leaf)
+        if (!member->m_condition && !member->m_is_leaf)
         {
             entriesWithoutConditionCount++;
             lastEntryWithoutCondition = index;
@@ -40,11 +40,13 @@ bool UnionsPostProcessor::PostProcess(IDataRepository* repository)
 {
     const auto& allInfos = repository->GetAllStructureInformation();
 
-    return std::all_of(allInfos.begin(), allInfos.end(), [](StructureInformation* info)
-    {
-        if (info->m_definition->GetType() != DataDefinitionType::UNION)
-            return true;
+    return std::all_of(allInfos.begin(),
+                       allInfos.end(),
+                       [](StructureInformation* info)
+                       {
+                           if (info->m_definition->GetType() != DataDefinitionType::UNION)
+                               return true;
 
-        return ProcessUnion(info);
-    });
+                           return ProcessUnion(info);
+                       });
 }

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/UsagesPostProcessor.cpp

@@ -1,12 +1,12 @@
 #include "UsagesPostProcessor.h"
 
+#include "Domain/Computations/MemberComputations.h"
+#include "Domain/Computations/StructureComputations.h"
+
 #include <algorithm>
 #include <queue>
 #include <set>
 
-#include "Domain/Computations/MemberComputations.h"
-#include "Domain/Computations/StructureComputations.h"
-
 bool UsagesPostProcessor::ProcessAsset(StructureInformation* info)
 {
     std::set<StructureInformation*> processedInfos;
@@ -14,23 +14,23 @@ bool UsagesPostProcessor::ProcessAsset(StructureInformation* info)
 
     processingQueue.push(info);
 
-    while(!processingQueue.empty())
+    while (!processingQueue.empty())
     {
         auto* currentStructure = processingQueue.front();
         processingQueue.pop();
 
-        if(processedInfos.find(currentStructure) != processedInfos.end())
+        if (processedInfos.find(currentStructure) != processedInfos.end())
             continue;
         processedInfos.emplace(currentStructure);
 
         for (const auto& member : currentStructure->m_ordered_members)
         {
-            if(member->m_type == nullptr)
+            if (member->m_type == nullptr)
                 continue;
 
             const MemberComputations computations(member.get());
 
-            if(computations.ShouldIgnore())
+            if (computations.ShouldIgnore())
                 continue;
 
             if (computations.ContainsNonEmbeddedReference())
@@ -63,9 +63,11 @@ bool UsagesPostProcessor::PostProcess(IDataRepository* repository)
 {
     const auto& allInfos = repository->GetAllStructureInformation();
 
-    return std::all_of(allInfos.begin(), allInfos.end(), [](StructureInformation* info)
-    {
-        const StructureComputations computations(info);
-        return !computations.IsAsset() || ProcessAsset(info);
-    });
+    return std::all_of(allInfos.begin(),
+                       allInfos.end(),
+                       [](StructureInformation* info)
+                       {
+                           const StructureComputations computations(info);
+                           return !computations.IsAsset() || ProcessAsset(info);
+                       });
 }