Reformat code with clang format

src/ZoneCommon/Zone/AssetList/AssetList.h

@@ -17,4 +17,4 @@ class AssetList
 {
 public:
     std::vector<AssetListEntry> m_entries;
-};
+};

src/ZoneCommon/Zone/AssetList/AssetListStream.h

@@ -1,9 +1,9 @@
 #pragma once
-#include <iostream>
-
 #include "AssetList.h"
 #include "Csv/CsvStream.h"
 
+#include <iostream>
+
 class AssetListInputStream
 {
     CsvInputStream m_stream;
@@ -22,4 +22,4 @@ public:
     explicit AssetListOutputStream(std::ostream& stream);
 
     void WriteEntry(const AssetListEntry& entry);
-};
+};

src/ZoneCommon/Zone/Definition/ZoneDefinition.cpp

@@ -12,8 +12,7 @@ ZoneDefinitionEntry::ZoneDefinitionEntry(std::string type, std::string name, con
 {
 }
 
-ZoneMetaDataEntry::ZoneMetaDataEntry()
-= default;
+ZoneMetaDataEntry::ZoneMetaDataEntry() = default;
 
 ZoneMetaDataEntry::ZoneMetaDataEntry(std::string key, std::string value)
     : m_key(std::move(key)),

src/ZoneCommon/Zone/Definition/ZoneDefinition.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <string>
+#include "Zone/AssetList/AssetList.h"
+
 #include <memory>
+#include <string>
 #include <unordered_map>
 #include <vector>
 
-#include "Zone/AssetList/AssetList.h"
-
 class ZoneDefinitionEntry
 {
 public:
@@ -43,4 +43,4 @@ public:
     void AddMetaData(std::string key, std::string value);
     void Include(const AssetList& assetListToInclude);
     void Include(const ZoneDefinition& definitionToInclude);
-};
+};

src/ZoneCommon/Zone/Definition/ZoneDefinitionStream.cpp

@@ -1,15 +1,14 @@
 #include "ZoneDefinitionStream.h"
 
-#include <chrono>
-
-#include "Parsing/Impl/ParserSingleInputStream.h"
-#include <Parsing/Impl/CommentRemovingStreamProxy.h>
-
 #include "Parsing/Impl/DefinesStreamProxy.h"
+#include "Parsing/Impl/ParserSingleInputStream.h"
 #include "Parsing/Simple/SimpleLexer.h"
 #include "Parsing/ZoneDefinition/ZoneDefinitionLexer.h"
 #include "Parsing/ZoneDefinition/ZoneDefinitionParser.h"
 
+#include <Parsing/Impl/CommentRemovingStreamProxy.h>
+#include <chrono>
+
 ZoneDefinitionInputStream::ZoneDefinitionInputStream(std::istream& stream, std::string fileName, bool verbose)
     : m_file_name(std::move(fileName)),
       m_verbose(verbose),
@@ -84,8 +83,7 @@ void ZoneDefinitionOutputStream::WriteEntry(const std::string& entryKey, const s
 {
     m_stream << entryKey << ",";
 
-    if (entryValue.find('"') != std::string::npos
-        || entryValue.find("//") != std::string::npos)
+    if (entryValue.find('"') != std::string::npos || entryValue.find("//") != std::string::npos)
     {
         m_stream << '"';
         for (const auto& c : entryValue)

src/ZoneCommon/Zone/Definition/ZoneDefinitionStream.h

@@ -1,10 +1,10 @@
 #pragma once
+#include "Parsing/IParserLineStream.h"
+#include "ZoneDefinition.h"
+
 #include <iostream>
 #include <memory>
 
-#include "ZoneDefinition.h"
-#include "Parsing/IParserLineStream.h"
-
 class ZoneDefinitionInputStream
 {
     static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator";
@@ -35,4 +35,4 @@ public:
     void WriteComment(const std::string& comment) const;
     void WriteMetaData(const std::string& metaDataKey, const std::string& metaDataValue) const;
     void WriteEntry(const std::string& entryKey, const std::string& entryValue) const;
-};
+};

src/ZoneCommon/Zone/Stream/IZoneStream.h

@@ -13,4 +13,4 @@ public:
 
     virtual void PushBlock(block_t block) = 0;
     virtual block_t PopBlock() = 0;
-};
+};

src/ZoneCommon/Zone/XBlock.cpp

@@ -1,4 +1,5 @@
 #include "XBlock.h"
+
 #include <cassert>
 
 XBlock::XBlock(const std::string& name, const int index, const Type type)
@@ -20,7 +21,7 @@ void XBlock::Alloc(const size_t blockSize)
 {
     delete[] m_buffer;
 
-    if(blockSize > 0)
+    if (blockSize > 0)
     {
         m_buffer = new uint8_t[blockSize];
         m_buffer_size = blockSize;
@@ -30,4 +31,4 @@ void XBlock::Alloc(const size_t blockSize)
         m_buffer = nullptr;
         m_buffer_size = 0;
     }
-}
+}

src/ZoneCommon/Zone/XChunk/AbstractSalsa20Processor.h

@@ -1,12 +1,12 @@
 #pragma once
+#include "Crypto.h"
+#include "Utils/ClassUtils.h"
+#include "Utils/ICapturedDataProvider.h"
+
 #include <cstdint>
 #include <memory>
 #include <string>
 
-#include "Utils/ClassUtils.h"
-#include "Crypto.h"
-#include "Utils/ICapturedDataProvider.h"
-
 class AbstractSalsa20Processor : public ICapturedDataProvider
 {
 protected:

src/ZoneCommon/Zone/XChunk/IXChunkProcessor.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <cstdint>
 #include <cstddef>
+#include <cstdint>
 
 class IXChunkProcessor
 {

src/ZoneCommon/Zone/XChunk/XChunkException.h

@@ -1,9 +1,9 @@
 #pragma once
+#include "Utils/ClassUtils.h"
+
 #include <exception>
 #include <string>
 
-#include "Utils/ClassUtils.h"
-
 class XChunkException final : public std::exception
 {
     std::string m_message;

src/ZoneCommon/Zone/XChunk/XChunkProcessorDeflate.cpp

@@ -1,19 +1,18 @@
 #include "XChunkProcessorDeflate.h"
 
+#include "XChunkException.h"
 
 #include <cassert>
 #include <zlib.h>
 #include <zutil.h>
 
-#include "XChunkException.h"
-
 size_t XChunkProcessorDeflate::Process(int streamNumber, const uint8_t* input, const size_t inputLength, uint8_t* output, const size_t outputBufferSize)
 {
     z_stream stream{};
     stream.zalloc = Z_NULL;
     stream.zfree = Z_NULL;
     stream.opaque = Z_NULL;
-    
+
     auto ret = deflateInit2(&stream, Z_BEST_COMPRESSION, Z_DEFLATED, -DEF_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
     if (ret != Z_OK)
         throw XChunkException("Initializing deflate failed.");

src/ZoneCommon/Zone/XChunk/XChunkProcessorInflate.cpp

@@ -1,10 +1,10 @@
 #include "XChunkProcessorInflate.h"
 
+#include "XChunkException.h"
+
 #include <zlib.h>
 #include <zutil.h>
 
-#include "XChunkException.h"
-
 size_t XChunkProcessorInflate::Process(int streamNumber, const uint8_t* input, const size_t inputLength, uint8_t* output, const size_t outputBufferSize)
 {
     z_stream stream{};

src/ZoneCommon/Zone/XChunk/XChunkProcessorSalsa20Decryption.cpp

@@ -1,16 +1,20 @@
 #include "XChunkProcessorSalsa20Decryption.h"
 
+#include "AbstractSalsa20Processor.h"
+#include "Crypto.h"
+
 #include <cassert>
 
-#include "Crypto.h"
-#include "AbstractSalsa20Processor.h"
-
-XChunkProcessorSalsa20Decryption::XChunkProcessorSalsa20Decryption(const int streamCount, std::string& zoneName, const uint8_t* salsa20Key, const size_t keySize)
+XChunkProcessorSalsa20Decryption::XChunkProcessorSalsa20Decryption(const int streamCount,
+                                                                   std::string& zoneName,
+                                                                   const uint8_t* salsa20Key,
+                                                                   const size_t keySize)
     : AbstractSalsa20Processor(streamCount, zoneName, salsa20Key, keySize)
 {
 }
 
-size_t XChunkProcessorSalsa20Decryption::Process(const int streamNumber, const uint8_t* input, const size_t inputLength, uint8_t* output, const size_t outputBufferSize)
+size_t XChunkProcessorSalsa20Decryption::Process(
+    const int streamNumber, const uint8_t* input, const size_t inputLength, uint8_t* output, const size_t outputBufferSize)
 {
     assert(streamNumber >= 0 && streamNumber < m_stream_count);
     assert(input != nullptr);

src/ZoneCommon/Zone/XChunk/XChunkProcessorSalsa20Decryption.h

@@ -1,8 +1,8 @@
 #pragma once
-#include <string>
-
-#include "IXChunkProcessor.h"
 #include "AbstractSalsa20Processor.h"
+#include "IXChunkProcessor.h"
+
+#include <string>
 
 class XChunkProcessorSalsa20Decryption final : public IXChunkProcessor, public AbstractSalsa20Processor
 {

src/ZoneCommon/Zone/XChunk/XChunkProcessorSalsa20Encryption.cpp

@@ -2,12 +2,16 @@
 
 #include <cassert>
 
-XChunkProcessorSalsa20Encryption::XChunkProcessorSalsa20Encryption(const int streamCount, std::string& zoneName, const uint8_t* salsa20Key, const size_t keySize)
+XChunkProcessorSalsa20Encryption::XChunkProcessorSalsa20Encryption(const int streamCount,
+                                                                   std::string& zoneName,
+                                                                   const uint8_t* salsa20Key,
+                                                                   const size_t keySize)
     : AbstractSalsa20Processor(streamCount, zoneName, salsa20Key, keySize)
 {
 }
 
-size_t XChunkProcessorSalsa20Encryption::Process(const int streamNumber, const uint8_t* input, const size_t inputLength, uint8_t* output, const size_t outputBufferSize)
+size_t XChunkProcessorSalsa20Encryption::Process(
+    const int streamNumber, const uint8_t* input, const size_t inputLength, uint8_t* output, const size_t outputBufferSize)
 {
     assert(streamNumber >= 0 && streamNumber < m_stream_count);
     assert(input != nullptr);

src/ZoneCommon/Zone/XChunk/XChunkProcessorSalsa20Encryption.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <string>
-
 #include "AbstractSalsa20Processor.h"
 #include "IXChunkProcessor.h"
 
+#include <string>
+
 class XChunkProcessorSalsa20Encryption final : public IXChunkProcessor, public AbstractSalsa20Processor
 {
 public:

src/ZoneCommon/Zone/Zone.h

@@ -1,16 +1,16 @@
 #pragma once
 
+#include "Game/GameLanguage.h"
+#include "Game/IGame.h"
+#include "Pool/ZoneAssetPools.h"
+#include "Utils/ClassUtils.h"
+#include "Zone/ZoneTypes.h"
+#include "ZoneMemory.h"
+#include "ZoneScriptStrings.h"
+
 #include <memory>
 #include <string>
 
-#include "Utils/ClassUtils.h"
-#include "Zone/ZoneTypes.h"
-#include "Pool/ZoneAssetPools.h"
-#include "Game/IGame.h"
-#include "Game/GameLanguage.h"
-#include "ZoneMemory.h"
-#include "ZoneScriptStrings.h"
-
 class IGame;
 class ZoneAssetPools;
 

src/ZoneCommon/Zone/ZoneMemory.cpp

@@ -1,7 +1,6 @@
 #include "ZoneMemory.h"
 
-ZoneMemory::ZoneMemory()
-= default;
+ZoneMemory::ZoneMemory() = default;
 
 void ZoneMemory::AddBlock(std::unique_ptr<XBlock> block)
 {

src/ZoneCommon/Zone/ZoneMemory.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <memory>
-#include <vector>
-
 #include "Utils/MemoryManager.h"
 #include "Zone/XBlock.h"
 
+#include <memory>
+#include <vector>
+
 class ZoneMemory : public MemoryManager
 {
     std::vector<std::unique_ptr<XBlock>> m_blocks;

src/ZoneCommon/Zone/ZoneScriptStrings.cpp

@@ -1,8 +1,8 @@
 #include "ZoneScriptStrings.h"
 
 #include <cassert>
-#include <stdexcept>
 #include <sstream>
+#include <stdexcept>
 
 ZoneScriptStrings::ZoneScriptStrings()
     : m_null_entry_pos(0)

src/ZoneCommon/Zone/ZoneScriptStrings.h

@@ -1,13 +1,13 @@
 #pragma once
 
+#include "Utils/ClassUtils.h"
+#include "Zone/ZoneTypes.h"
+
 #include <cstddef>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
-#include "Utils/ClassUtils.h"
-#include "Zone/ZoneTypes.h"
-
 class ZoneScriptStrings
 {
     int m_null_entry_pos;
@@ -36,4 +36,4 @@ public:
     _NODISCARD const std::string& operator[](size_t index) const;
     _NODISCARD std::vector<std::string>::const_iterator begin() const;
     _NODISCARD std::vector<std::string>::const_iterator end() const;
-};
+};