chore: format code

.clang-format

@@ -0,0 +1,130 @@
+---
+AccessModifierOffset: 0
+AlignAfterOpenBracket: BlockIndent
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments: None
+AlignConsecutiveMacros: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: DontAlign
+AlignOperands: DontAlign
+AlignTrailingComments: false
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Empty
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: MultiLine
+AttributeMacros: []
+BinPackArguments: false
+BinPackParameters: false
+BitFieldColonSpacing: After
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: Never
+  AfterEnum: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: false
+  BeforeElse: false
+  BeforeLambdaBody: false
+  BeforeWhile: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakAfterJavaFieldAnnotations: true
+#BreakArrays: false
+BreakBeforeBinaryOperators: All
+BreakBeforeBraces: Custom
+BreakBeforeConceptDeclarations: true
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+BreakInheritanceList: AfterColon
+BreakStringLiterals: true
+ColumnLimit: 90
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: false
+DeriveLineEnding: false
+DerivePointerAlignment: false
+DisableFormat: false # wtf
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: Always
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: false
+ForEachMacros: ["BOOST_FOREACH"]
+IfMacros: []
+IncludeBlocks: Regroup
+IndentAccessModifiers: false
+IndentCaseBlocks: false
+IndentCaseLabels: true
+IndentExternBlock: Indent
+IndentGotoLabels: true
+IndentPPDirectives: BeforeHash
+#IndentRequiresClause: false
+IndentWidth: 4
+IndentWrappedFunctionNames: false
+#InsertBraces: false
+InsertTrailingCommas: Wrapped
+JavaImportGroups: ["java"]
+JavaScriptQuotes: Double
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: OuterScope
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+PackConstructorInitializers: NextLine
+PointerAlignment: Left
+QualifierAlignment: Left
+ReferenceAlignment: Left
+ReflowComments: true
+#RemoveSemicolon: true
+#RequiresClausePosition: OwnLine
+#RequiresExpressionIndentation: OuterScope
+SeparateDefinitionBlocks: Always
+SortIncludes: CaseInsensitive
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceAroundPointerQualifiers: After
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: false
+SpaceBeforeInheritanceColon: false
+SpaceBeforeParens: ControlStatementsExceptControlMacros
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesInAngles: Never
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
+SpacesInLineCommentPrefix:
+  Minimum: 0
+  Maximum: -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: c++20
+StatementAttributeLikeMacros: []
+StatementMacros: []
+TabWidth: 4
+TypenameMacros: []
+UseCRLF: false # wtf
+UseTab: Never
+WhitespaceSensitiveMacros: ["BOOST_PP_STRINGSIZE"]

src/ansi.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
 namespace ansi {
-const char *reset = "\033[0m";
+    inline const char* reset = "\033[0m";
 
-const char *cyan = "\033[0;36m";
+    inline const char* cyan = "\033[0;36m";
-const char *green = "\033[0;32m";
+    inline const char* green = "\033[0;32m";
-const char *yellow = "\033[0;33m";
+    inline const char* yellow = "\033[0;33m";
-} // namespace ansi
+}

src/client.cpp

@@ -1,5 +1,6 @@
 #include "data.hpp"
 #include "resourceloc.hpp"
+
 #include <boost/log/trivial.hpp>
 #include <cerrno>
 #include <cstring>
@@ -17,8 +18,15 @@ void sendMsg(int msqid, data::RequestMapMsg *msg) {
 
     std::string recvMsg(int msqid) {
         data::ResponseMapMsg msg;
-  if (msgrcv(msqid, &msg, sizeof(data::ResponseMapMsg) - sizeof(long),
+
-             data::clientbound_msg, 0) < 0) {
+        if (msgrcv(
+                msqid,
+                &msg,
+                sizeof(data::ResponseMapMsg) - sizeof(long),
+                data::clientbound_msg,
+                0
+            )
+            < 0) {
             throw std::runtime_error(std::string("receive error ") + strerror(errno));
         }
 
@@ -50,4 +58,4 @@ void resolveResourceLoc(key_t key) {
 
         std::cout << resourceloc::resolve(inp) << std::endl;
     }
-} // namespace client
+}

src/client.hpp

@@ -5,4 +5,4 @@
 namespace client {
     void map(key_t key);
     void resolveResourceLoc(key_t key);
-} // namespace client
+}

src/csv.cpp

@@ -1,10 +1,15 @@
 #include "csv.hpp"
+
 #include <istream>
 #include <string>
 #include <vector>
 
 namespace csv {
-enum class CSVState { UnquotedField, QuotedField, QuotedQuote };
+    enum class CSVState {
+        UnquotedField,
+        QuotedField,
+        QuotedQuote
+    };
 
     // this function has been made in collaboration with
     // StackOverflow https://stackoverflow.com/a/30338543
@@ -12,6 +17,7 @@ void readCSVRow(const std::string &row, std::vector<std::string> &fields) {
         fields.push_back("");
         CSVState state = CSVState::UnquotedField;
         size_t i = 0; // index of the current field
+
         for (char c : row) {
             switch (state) {
                 case CSVState::UnquotedField:
@@ -20,24 +26,31 @@ void readCSVRow(const std::string &row, std::vector<std::string> &fields) {
                             fields.push_back("");
                             i++;
                             break;
+
                         case '"':
                             state = CSVState::QuotedField;
                             break;
+
                         default:
                             fields[i].push_back(c);
                             break;
                     }
+
                     break;
+
                 case CSVState::QuotedField:
                     switch (c) {
                         case '"':
                             state = CSVState::QuotedQuote;
                             break;
+
                         default:
                             fields[i].push_back(c);
                             break;
                     }
+
                     break;
+
                 case CSVState::QuotedQuote:
                     switch (c) {
                         case ',': // , after closing quote
@@ -45,20 +58,25 @@ void readCSVRow(const std::string &row, std::vector<std::string> &fields) {
                             i++;
                             state = CSVState::UnquotedField;
                             break;
+
                         case '"': // "" -> "
                             fields[i].push_back('"');
                             state = CSVState::QuotedField;
                             break;
+
                         default: // end of quote
                             state = CSVState::UnquotedField;
                             break;
                     }
+
                     break;
             }
         }
     }
+
     bool CsvReader::operator>>(std::vector<std::string>& line) {
         line.clear();
+
         if (!m_stream) {
             return false;
         }
@@ -70,4 +88,4 @@ bool CsvReader::operator>>(std::vector<std::string> &line) {
 
         return !!m_stream;
     }
-} // namespace csv
+}

src/csv.hpp

@@ -2,6 +2,7 @@
 #include <fstream>
 #include <string>
 #include <vector>
+
 namespace csv {
     class CsvReader {
         private:
@@ -13,4 +14,4 @@ public:
 
         bool operator>>(std::vector<std::string>& line);
     };
-} // namespace csv
+}

src/data.cpp

@@ -1,4 +1,5 @@
 #include "data.hpp"
+
 #include <boost/log/trivial.hpp>
 #include <cstdlib>
 #include <stdexcept>
@@ -14,4 +15,4 @@ key_t getIpcKeyFromExeName(char *argv0) {
 
         return k;
     }
-} // namespace data
+}

src/data.hpp

@@ -21,4 +21,4 @@ struct ResponseMapMsg {
         unsigned int datalen;
         char data[128];
     };
-} // namespace data
+}

src/main.cpp

@@ -1,6 +1,7 @@
 #include "client.hpp"
 #include "data.hpp"
 #include "server.hpp"
+
 #include <boost/log/trivial.hpp>
 #include <cstring>
 #include <stdexcept>

src/mappings.cpp

@@ -1,6 +1,8 @@
 #include "mappings.hpp"
+
 #include "ansi.hpp"
 #include "csv.hpp"
+
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
@@ -24,29 +26,35 @@ Mappings Mappings::load() {
 
         // load mappings
         fs::directory_iterator end_itr;
+
         try {
             for (fs::directory_iterator itr("mappings"); itr != end_itr; ++itr) {
-      if (fs::is_directory(itr->status()) ||
+                if (fs::is_directory(itr->status())
-          !boost::algorithm::ends_with(itr->path().string(), ".csv"))
+                    || !boost::algorithm::ends_with(itr->path().string(), ".csv"))
                     continue;
 
                 csv::CsvReader csv(itr->path().string());
 
                 std::vector<std::string> l;
+
                 while (csv >> l) {
                     if (l.size() < 2) {
                         BOOST_LOG_TRIVIAL(warning) << "found invalid mapping";
                         continue;
                     }
-        mappings[l[0]] = {l[0], l[1],
+
-                          l.size() >= 4 ? std::optional(l[3]) : std::nullopt};
+                    mappings[l[0]] = {
+                        l[0], l[1], l.size() >= 4 ? std::optional(l[3]) : std::nullopt
+                    };
                 }
             }
         } catch (boost::filesystem::filesystem_error& e) {
             if (e.code() == boost::system::errc::no_such_file_or_directory) {
                 throw std::runtime_error(
-          std::string("The mappings directory is missing!\n") + e.what());
+                    std::string("The mappings directory is missing!\n") + e.what()
+                );
             }
+
             throw;
         }
 
@@ -54,6 +62,7 @@ Mappings Mappings::load() {
             csv::CsvReader csv("renames.csv");
 
             std::vector<std::string> l;
+
             while (csv >> l) {
                 if (l.size() < 2) {
                     BOOST_LOG_TRIVIAL(warning) << "found invalid rename";
@@ -75,6 +84,7 @@ void showMapInfo(Mapping mapping, std::optional<std::string> rename) {
         auto doc = mapping.doc.has_value()
             ? std::string(ansi::yellow) + "\n\n\t" + *mapping.doc + "\n"
             : "";
+
         if (rename.has_value()) {
             BOOST_LOG_TRIVIAL(info)
                 << "\nFound mapping:\n"
@@ -83,11 +93,10 @@ void showMapInfo(Mapping mapping, std::optional<std::string> rename) {
                 << ansi::cyan << "\n\tRenamed \t" << ansi::green << *rename << doc
                 << ansi::reset;
         } else {
-    BOOST_LOG_TRIVIAL(info)
+            BOOST_LOG_TRIVIAL(info) << "\nFound mapping:\n"
-        << "\nFound mapping:\n"
+                                    << ansi::cyan << "\n\tOriginal\t" << ansi::green
-        << ansi::cyan << "\n\tOriginal\t" << ansi::green << mapping.orig
+                                    << mapping.orig << ansi::cyan << "\n\tRemapped\t"
-        << ansi::cyan << "\n\tRemapped\t" << ansi::green << mapping.name << doc
+                                    << ansi::green << mapping.name << doc << ansi::reset;
-        << ansi::reset;
         }
     }
 
@@ -109,4 +118,4 @@ std::string Mappings::map(std::string inp) {
         showMapInfo(mapped, std::nullopt);
         return mapped.name;
     }
-} // namespace mappings
+}

src/mappings.hpp

@@ -15,13 +15,14 @@ class Mappings {
         std::map<std::string, std::string> m_renames;
 
         public:
-  Mappings(std::map<std::string, Mapping> mappings,
+        Mappings(
-           std::map<std::string, std::string> renames) {
+            std::map<std::string, Mapping> mappings,
-    this->m_mappings = mappings;
+            std::map<std::string, std::string> renames
-    this->m_renames = renames;
+        ):
-  }
+            m_mappings(mappings), m_renames(renames) {}
+
         ~Mappings() = default;
         static Mappings load();
         std::string map(std::string inp);
     };
-} // namespace mappings
+}

src/resourceloc.cpp

@@ -1,4 +1,5 @@
 #include "resourceloc.hpp"
+
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/format.hpp>
@@ -21,14 +22,18 @@ std::string resolve(std::string inp) {
         }
 
         std::string path_component;
+
         for (unsigned int i = 3; i < components.size(); i++) {
             path_component += components[i];
+
             if (i != components.size() - 1) {
                 path_component += "/";
             }
         }
 
-  return boost::str(boost::format("new ResourceLocation(\"%1%\", \"%2%\")") %
+        return boost::str(
-                    components[2] % path_component);
+            boost::format("new ResourceLocation(\"%1%\", \"%2%\")") % components[2]
+            % path_component
+        );
+    }
 }
-} // namespace resourceloc

src/resourceloc.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <string>
+
 namespace resourceloc {
     std::string resolve(std::string inp);
 }

src/server.cpp

@@ -1,7 +1,9 @@
 #include "server.hpp"
+
 #include "data.hpp"
 #include "mappings.hpp"
 #include "resourceloc.hpp"
+
 #include <algorithm>
 #include <boost/log/trivial.hpp>
 #include <cstdlib>
@@ -36,9 +38,16 @@ void run(key_t key) {
         auto mappings = mappings::Mappings::load();
 
         data::RequestMapMsg msg;
+
         for (;;) {
-    if (msgrcv(msqid, &msg, sizeof(data::RequestMapMsg) - sizeof(long),
+            if (msgrcv(
-               data::serverbound_msg, 0) < 0) {
+                    msqid,
+                    &msg,
+                    sizeof(data::RequestMapMsg) - sizeof(long),
+                    data::serverbound_msg,
+                    0
+                )
+                < 0) {
                 BOOST_LOG_TRIVIAL(error) << "receive error " << strerror(errno);
                 continue;
             }
@@ -48,4 +57,4 @@ void run(key_t key) {
             sendToClient(msqid, mappings.map(s));
         }
     }
-} // namespace server
+}