From b76daa2927a142c606e04109a1954af7ba005902 Mon Sep 17 00:00:00 2001 From: LordMZTE Date: Wed, 9 Nov 2022 22:02:26 +0100 Subject: [PATCH] chore: format code --- .clang-format | 130 +++++++++++++++++++++++++++++++++ src/ansi.hpp | 10 +-- src/client.cpp | 90 ++++++++++++----------- src/client.hpp | 6 +- src/csv.cpp | 144 +++++++++++++++++++++---------------- src/csv.hpp | 19 ++--- src/data.cpp | 15 ++-- src/data.hpp | 28 ++++---- src/main.cpp | 43 +++++------ src/mappings.cpp | 171 +++++++++++++++++++++++--------------------- src/mappings.hpp | 39 +++++----- src/resourceloc.cpp | 41 ++++++----- src/resourceloc.hpp | 3 +- src/server.cpp | 77 +++++++++++--------- src/server.hpp | 2 +- 15 files changed, 501 insertions(+), 317 deletions(-) create mode 100644 .clang-format diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..d48bed8 --- /dev/null +++ b/.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"] diff --git a/src/ansi.hpp b/src/ansi.hpp index 0a80425..88d0d5a 100644 --- a/src/ansi.hpp +++ b/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"; -const char *green = "\033[0;32m"; -const char *yellow = "\033[0;33m"; -} // namespace ansi + inline const char* cyan = "\033[0;36m"; + inline const char* green = "\033[0;32m"; + inline const char* yellow = "\033[0;33m"; +} diff --git a/src/client.cpp b/src/client.cpp index 8473b29..36b28f6 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -1,5 +1,6 @@ #include "data.hpp" #include "resourceloc.hpp" + #include #include #include @@ -9,45 +10,52 @@ #include namespace client { -void sendMsg(int msqid, data::RequestMapMsg *msg) { - if (msgsnd(msqid, msg, sizeof(data::RequestMapMsg) - sizeof(long), 0) < 0) { - throw std::runtime_error(std::string("send error ") + strerror(errno)); - } + void sendMsg(int msqid, data::RequestMapMsg* msg) { + if (msgsnd(msqid, msg, sizeof(data::RequestMapMsg) - sizeof(long), 0) < 0) { + throw std::runtime_error(std::string("send error ") + strerror(errno)); + } + } + + std::string recvMsg(int msqid) { + data::ResponseMapMsg msg; + + if (msgrcv( + msqid, + &msg, + sizeof(data::ResponseMapMsg) - sizeof(long), + data::clientbound_msg, + 0 + ) + < 0) { + throw std::runtime_error(std::string("receive error ") + strerror(errno)); + } + + return std::string(&msg.data[0], msg.datalen); + } + + void map(key_t key) { + std::string inp; + std::cin >> inp; + + auto msqid = msgget(key, 0664); + + if (msqid < 0) { + throw std::runtime_error("msgget fail. is the server running?"); + } + + data::RequestMapMsg req; + req.msgtype = data::serverbound_msg; + req.datalen = inp.size(); + std::copy(inp.begin(), inp.end(), req.data); + + sendMsg(msqid, &req); + std::cout << recvMsg(msqid) << std::endl; + } + + void resolveResourceLoc(key_t key) { + std::string inp; + std::cin >> inp; + + std::cout << resourceloc::resolve(inp) << std::endl; + } } - -std::string recvMsg(int msqid) { - data::ResponseMapMsg msg; - if (msgrcv(msqid, &msg, sizeof(data::ResponseMapMsg) - sizeof(long), - data::clientbound_msg, 0) < 0) { - throw std::runtime_error(std::string("receive error ") + strerror(errno)); - } - - return std::string(&msg.data[0], msg.datalen); -} - -void map(key_t key) { - std::string inp; - std::cin >> inp; - - auto msqid = msgget(key, 0664); - - if (msqid < 0) { - throw std::runtime_error("msgget fail. is the server running?"); - } - - data::RequestMapMsg req; - req.msgtype = data::serverbound_msg; - req.datalen = inp.size(); - std::copy(inp.begin(), inp.end(), req.data); - - sendMsg(msqid, &req); - std::cout << recvMsg(msqid) << std::endl; -} - -void resolveResourceLoc(key_t key) { - std::string inp; - std::cin >> inp; - - std::cout << resourceloc::resolve(inp) << std::endl; -} -} // namespace client diff --git a/src/client.hpp b/src/client.hpp index 0c33382..c6d2dd4 100644 --- a/src/client.hpp +++ b/src/client.hpp @@ -3,6 +3,6 @@ #include namespace client { -void map(key_t key); -void resolveResourceLoc(key_t key); -} // namespace client + void map(key_t key); + void resolveResourceLoc(key_t key); +} diff --git a/src/csv.cpp b/src/csv.cpp index a13a16a..665b6bc 100644 --- a/src/csv.cpp +++ b/src/csv.cpp @@ -1,73 +1,91 @@ #include "csv.hpp" + #include #include #include 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 -void readCSVRow(const std::string &row, std::vector &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: - switch (c) { - case ',': // end of field + // this function has been made in collaboration with + // StackOverflow https://stackoverflow.com/a/30338543 + void readCSVRow(const std::string& row, std::vector& 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 - fields.push_back(""); - i++; - state = CSVState::UnquotedField; - break; - case '"': // "" -> " - fields[i].push_back('"'); - state = CSVState::QuotedField; - break; - default: // end of quote - state = CSVState::UnquotedField; - break; - } - break; + CSVState state = CSVState::UnquotedField; + size_t i = 0; // index of the current field + + for (char c : row) { + switch (state) { + case CSVState::UnquotedField: + switch (c) { + case ',': // end of field + 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 + fields.push_back(""); + 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& line) { + line.clear(); + + if (!m_stream) { + return false; + } + + std::string row; + std::getline(m_stream, row); + + readCSVRow(row, line); + + return !!m_stream; } - } } -bool CsvReader::operator>>(std::vector &line) { - line.clear(); - if (!m_stream) { - return false; - } - - std::string row; - std::getline(m_stream, row); - - readCSVRow(row, line); - - return !!m_stream; -} -} // namespace csv diff --git a/src/csv.hpp b/src/csv.hpp index b1e042f..2030d72 100644 --- a/src/csv.hpp +++ b/src/csv.hpp @@ -2,15 +2,16 @@ #include #include #include + namespace csv { -class CsvReader { -private: - std::ifstream m_stream; + class CsvReader { + private: + std::ifstream m_stream; -public: - CsvReader(auto stream) : m_stream(stream){}; - ~CsvReader() = default; + public: + CsvReader(auto stream): m_stream(stream){}; + ~CsvReader() = default; - bool operator>>(std::vector &line); -}; -} // namespace csv + bool operator>>(std::vector& line); + }; +} diff --git a/src/data.cpp b/src/data.cpp index 847cafa..33f6b31 100644 --- a/src/data.cpp +++ b/src/data.cpp @@ -1,17 +1,18 @@ #include "data.hpp" + #include #include #include #include namespace data { -key_t getIpcKeyFromExeName(char *argv0) { - auto k = ftok(argv0, 'X'); + key_t getIpcKeyFromExeName(char* argv0) { + auto k = ftok(argv0, 'X'); - if (k < 0) { - throw std::runtime_error("failed to get IPC key"); - } + if (k < 0) { + throw std::runtime_error("failed to get IPC key"); + } - return k; + return k; + } } -} // namespace data diff --git a/src/data.hpp b/src/data.hpp index d21d491..3a10dd7 100644 --- a/src/data.hpp +++ b/src/data.hpp @@ -3,22 +3,22 @@ #include namespace data { -const int serverbound_msg = 1; -const int clientbound_msg = 2; + const int serverbound_msg = 1; + const int clientbound_msg = 2; -key_t getIpcKeyFromExeName(char *argv0); + key_t getIpcKeyFromExeName(char* argv0); -struct RequestMapMsg { - long msgtype; + struct RequestMapMsg { + long msgtype; - unsigned int datalen; - char data[128]; -}; + unsigned int datalen; + char data[128]; + }; -struct ResponseMapMsg { - long msgtype; + struct ResponseMapMsg { + long msgtype; - unsigned int datalen; - char data[128]; -}; -} // namespace data + unsigned int datalen; + char data[128]; + }; +} diff --git a/src/main.cpp b/src/main.cpp index 512dc71..b2b3b42 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,32 +1,33 @@ #include "client.hpp" #include "data.hpp" #include "server.hpp" + #include #include #include -void main2(int argc, char *argv[]) { - if (argc < 2) { - throw std::runtime_error("not enough arguments!"); - } +void main2(int argc, char* argv[]) { + if (argc < 2) { + throw std::runtime_error("not enough arguments!"); + } - if (strcmp(argv[1], "serve") == 0) { - server::run(data::getIpcKeyFromExeName(argv[0])); - } else if (strcmp(argv[1], "map") == 0) { - client::map(data::getIpcKeyFromExeName(argv[0])); - } else if (strcmp(argv[1], "resourceloc") == 0) { - client::resolveResourceLoc(data::getIpcKeyFromExeName(argv[0])); - } else { - throw std::runtime_error("unknown command!"); - } + if (strcmp(argv[1], "serve") == 0) { + server::run(data::getIpcKeyFromExeName(argv[0])); + } else if (strcmp(argv[1], "map") == 0) { + client::map(data::getIpcKeyFromExeName(argv[0])); + } else if (strcmp(argv[1], "resourceloc") == 0) { + client::resolveResourceLoc(data::getIpcKeyFromExeName(argv[0])); + } else { + throw std::runtime_error("unknown command!"); + } } -int main(int argc, char *argv[]) { - try { - main2(argc, argv); - return 0; - } catch (const std::exception &e) { - BOOST_LOG_TRIVIAL(fatal) << "Exception: " << e.what(); - return 1; - } +int main(int argc, char* argv[]) { + try { + main2(argc, argv); + return 0; + } catch (const std::exception& e) { + BOOST_LOG_TRIVIAL(fatal) << "Exception: " << e.what(); + return 1; + } } diff --git a/src/mappings.cpp b/src/mappings.cpp index 4464af0..5f364c3 100644 --- a/src/mappings.cpp +++ b/src/mappings.cpp @@ -1,6 +1,8 @@ #include "mappings.hpp" + #include "ansi.hpp" #include "csv.hpp" + #include #include #include @@ -18,95 +20,102 @@ namespace fs = boost::filesystem; namespace mappings { -Mappings Mappings::load() { - std::map mappings; - std::map renames; + Mappings Mappings::load() { + std::map mappings; + std::map renames; - // load mappings - fs::directory_iterator end_itr; - try { - for (fs::directory_iterator itr("mappings"); itr != end_itr; ++itr) { - if (fs::is_directory(itr->status()) || - !boost::algorithm::ends_with(itr->path().string(), ".csv")) - continue; + // load mappings + fs::directory_iterator end_itr; - csv::CsvReader csv(itr->path().string()); + try { + for (fs::directory_iterator itr("mappings"); itr != end_itr; ++itr) { + if (fs::is_directory(itr->status()) + || !boost::algorithm::ends_with(itr->path().string(), ".csv")) + continue; - std::vector l; - while (csv >> l) { - if (l.size() < 2) { - BOOST_LOG_TRIVIAL(warning) << "found invalid mapping"; - continue; + csv::CsvReader csv(itr->path().string()); + + std::vector 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 + }; + } + } + } 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() + ); + } + + throw; } - mappings[l[0]] = {l[0], l[1], - l.size() >= 4 ? std::optional(l[3]) : std::nullopt}; - } + + if (fs::is_regular_file("renames.csv")) { + csv::CsvReader csv("renames.csv"); + + std::vector l; + + while (csv >> l) { + if (l.size() < 2) { + BOOST_LOG_TRIVIAL(warning) << "found invalid rename"; + continue; + } + + renames[l[0]] = l[1]; + } + } else { + BOOST_LOG_TRIVIAL(warning) << "no renames found, skipping"; + } + + BOOST_LOG_TRIVIAL(info) << "loaded " << mappings.size() << " mappings and " + << renames.size() << " renames"; + return { mappings, renames }; } - } 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()); + + void showMapInfo(Mapping mapping, std::optional 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" + << ansi::cyan << "\n\tOriginal\t" << ansi::green << mapping.orig + << ansi::cyan << "\n\tRemapped\t" << ansi::green << mapping.name + << ansi::cyan << "\n\tRenamed \t" << ansi::green << *rename << doc + << ansi::reset; + } else { + BOOST_LOG_TRIVIAL(info) << "\nFound mapping:\n" + << ansi::cyan << "\n\tOriginal\t" << ansi::green + << mapping.orig << ansi::cyan << "\n\tRemapped\t" + << ansi::green << mapping.name << doc << ansi::reset; + } } - throw; - } - if (fs::is_regular_file("renames.csv")) { - csv::CsvReader csv("renames.csv"); + std::string Mappings::map(std::string inp) { + if (!this->m_mappings.count(inp)) { + BOOST_LOG_TRIVIAL(warning) << "unknown mapping '" << inp << "'"; + return ""; + } - std::vector l; - while (csv >> l) { - if (l.size() < 2) { - BOOST_LOG_TRIVIAL(warning) << "found invalid rename"; - continue; - } + auto mapped = this->m_mappings[inp]; - renames[l[0]] = l[1]; + if (this->m_renames.count(mapped.name)) { + BOOST_LOG_TRIVIAL(info) + << "found rename " << mapped.name << " -> " << m_renames[mapped.name]; + showMapInfo(mapped, m_renames[mapped.name]); + return m_renames[mapped.name]; + } + + showMapInfo(mapped, std::nullopt); + return mapped.name; } - } else { - BOOST_LOG_TRIVIAL(warning) << "no renames found, skipping"; - } - - BOOST_LOG_TRIVIAL(info) << "loaded " << mappings.size() << " mappings and " - << renames.size() << " renames"; - return {mappings, renames}; } - -void showMapInfo(Mapping mapping, std::optional 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" - << ansi::cyan << "\n\tOriginal\t" << ansi::green << mapping.orig - << ansi::cyan << "\n\tRemapped\t" << ansi::green << mapping.name - << ansi::cyan << "\n\tRenamed \t" << ansi::green << *rename << doc - << ansi::reset; - } else { - BOOST_LOG_TRIVIAL(info) - << "\nFound mapping:\n" - << ansi::cyan << "\n\tOriginal\t" << ansi::green << mapping.orig - << ansi::cyan << "\n\tRemapped\t" << ansi::green << mapping.name << doc - << ansi::reset; - } -} - -std::string Mappings::map(std::string inp) { - if (!this->m_mappings.count(inp)) { - BOOST_LOG_TRIVIAL(warning) << "unknown mapping '" << inp << "'"; - return ""; - } - - auto mapped = this->m_mappings[inp]; - - if (this->m_renames.count(mapped.name)) { - BOOST_LOG_TRIVIAL(info) - << "found rename " << mapped.name << " -> " << m_renames[mapped.name]; - showMapInfo(mapped, m_renames[mapped.name]); - return m_renames[mapped.name]; - } - - showMapInfo(mapped, std::nullopt); - return mapped.name; -} -} // namespace mappings diff --git a/src/mappings.hpp b/src/mappings.hpp index b873cec..58c2d6a 100644 --- a/src/mappings.hpp +++ b/src/mappings.hpp @@ -4,24 +4,25 @@ #include namespace mappings { -struct Mapping { - std::string orig; - std::string name; - std::optional doc; -}; + struct Mapping { + std::string orig; + std::string name; + std::optional doc; + }; -class Mappings { - std::map m_mappings; - std::map m_renames; + class Mappings { + std::map m_mappings; + std::map m_renames; -public: - Mappings(std::map mappings, - std::map renames) { - this->m_mappings = mappings; - this->m_renames = renames; - } - ~Mappings() = default; - static Mappings load(); - std::string map(std::string inp); -}; -} // namespace mappings + public: + Mappings( + std::map mappings, + std::map renames + ): + m_mappings(mappings), m_renames(renames) {} + + ~Mappings() = default; + static Mappings load(); + std::string map(std::string inp); + }; +} diff --git a/src/resourceloc.cpp b/src/resourceloc.cpp index f9dc416..9a0a482 100644 --- a/src/resourceloc.cpp +++ b/src/resourceloc.cpp @@ -1,4 +1,5 @@ #include "resourceloc.hpp" + #include #include #include @@ -9,26 +10,30 @@ #include namespace resourceloc { -std::string resolve(std::string inp) { - boost::algorithm::trim_if(inp, boost::is_any_of(" \n\r\"")); + std::string resolve(std::string inp) { + boost::algorithm::trim_if(inp, boost::is_any_of(" \n\r\"")); - std::vector components; - boost::algorithm::split(components, inp, boost::is_any_of("/")); + std::vector components; + boost::algorithm::split(components, inp, boost::is_any_of("/")); - if (components.size() < 3 || components[0] != "" || components[1] != "mods") { - BOOST_LOG_TRIVIAL(warning) << "invalid resourceloc"; - return ""; - } + if (components.size() < 3 || components[0] != "" || components[1] != "mods") { + BOOST_LOG_TRIVIAL(warning) << "invalid resourceloc"; + return ""; + } - std::string path_component; - for (unsigned int i = 3; i < components.size(); i++) { - path_component += components[i]; - if (i != components.size() - 1) { - path_component += "/"; + 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%\")") % components[2] + % path_component + ); } - } - - return boost::str(boost::format("new ResourceLocation(\"%1%\", \"%2%\")") % - components[2] % path_component); } -} // namespace resourceloc diff --git a/src/resourceloc.hpp b/src/resourceloc.hpp index b86c13a..93a7c0b 100644 --- a/src/resourceloc.hpp +++ b/src/resourceloc.hpp @@ -1,5 +1,6 @@ #pragma once #include + namespace resourceloc { -std::string resolve(std::string inp); + std::string resolve(std::string inp); } diff --git a/src/server.cpp b/src/server.cpp index bcf7d74..099fb08 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -1,7 +1,9 @@ #include "server.hpp" + #include "data.hpp" #include "mappings.hpp" #include "resourceloc.hpp" + #include #include #include @@ -11,41 +13,48 @@ #include namespace server { -void sendToClient(int msqid, std::string msg) { - data::ResponseMapMsg pkt; - pkt.msgtype = data::clientbound_msg; - pkt.datalen = msg.size(); - std::copy(msg.begin(), msg.end(), pkt.data); + void sendToClient(int msqid, std::string msg) { + data::ResponseMapMsg pkt; + pkt.msgtype = data::clientbound_msg; + pkt.datalen = msg.size(); + std::copy(msg.begin(), msg.end(), pkt.data); - if (msgsnd(msqid, &pkt, sizeof(data::ResponseMapMsg) - sizeof(long), 0) < 0) { - BOOST_LOG_TRIVIAL(error) << "failed to send response " << strerror(errno); - } -} - -void run(key_t key) { - BOOST_LOG_TRIVIAL(info) << "starting server"; - - auto msqid = msgget(key, 0664 | IPC_CREAT); - - if (msqid < 0) { - throw std::runtime_error("msgget fail"); - } - - BOOST_LOG_TRIVIAL(info) << "msqid " << msqid; - - auto mappings = mappings::Mappings::load(); - - data::RequestMapMsg msg; - for (;;) { - if (msgrcv(msqid, &msg, sizeof(data::RequestMapMsg) - sizeof(long), - data::serverbound_msg, 0) < 0) { - BOOST_LOG_TRIVIAL(error) << "receive error " << strerror(errno); - continue; + if (msgsnd(msqid, &pkt, sizeof(data::ResponseMapMsg) - sizeof(long), 0) < 0) { + BOOST_LOG_TRIVIAL(error) << "failed to send response " << strerror(errno); + } } - std::string s(msg.data, msg.datalen); - BOOST_LOG_TRIVIAL(info) << "got request to map '" << s << "'"; - sendToClient(msqid, mappings.map(s)); - } + void run(key_t key) { + BOOST_LOG_TRIVIAL(info) << "starting server"; + + auto msqid = msgget(key, 0664 | IPC_CREAT); + + if (msqid < 0) { + throw std::runtime_error("msgget fail"); + } + + BOOST_LOG_TRIVIAL(info) << "msqid " << msqid; + + auto mappings = mappings::Mappings::load(); + + data::RequestMapMsg msg; + + for (;;) { + if (msgrcv( + msqid, + &msg, + sizeof(data::RequestMapMsg) - sizeof(long), + data::serverbound_msg, + 0 + ) + < 0) { + BOOST_LOG_TRIVIAL(error) << "receive error " << strerror(errno); + continue; + } + + std::string s(msg.data, msg.datalen); + BOOST_LOG_TRIVIAL(info) << "got request to map '" << s << "'"; + sendToClient(msqid, mappings.map(s)); + } + } } -} // namespace server diff --git a/src/server.hpp b/src/server.hpp index 380dd7f..2094149 100644 --- a/src/server.hpp +++ b/src/server.hpp @@ -3,5 +3,5 @@ #include namespace server { -void run(key_t key); + void run(key_t key); }