diff options
Diffstat (limited to 'src/server/game/Chat/ChatCommands')
| -rw-r--r-- | src/server/game/Chat/ChatCommands/ChatCommand.h | 259 | ||||
| -rw-r--r-- | src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp | 42 | ||||
| -rw-r--r-- | src/server/game/Chat/ChatCommands/ChatCommandArgs.h | 151 | ||||
| -rw-r--r-- | src/server/game/Chat/ChatCommands/ChatCommandHelpers.h | 36 | ||||
| -rw-r--r-- | src/server/game/Chat/ChatCommands/ChatCommandTags.h | 112 |
5 files changed, 312 insertions, 288 deletions
diff --git a/src/server/game/Chat/ChatCommands/ChatCommand.h b/src/server/game/Chat/ChatCommands/ChatCommand.h index 65584ce7430..c54f7f52cb5 100644 --- a/src/server/game/Chat/ChatCommands/ChatCommand.h +++ b/src/server/game/Chat/ChatCommands/ChatCommand.h @@ -33,106 +33,199 @@ class ChatHandler; class CommandArgs; -namespace Trinity::Impl::ChatCommands +template <typename T> +struct CommandArgsConsumerSingle { - template <typename T> - struct SingleConsumer + using arginfo = Trinity::ChatCommands::ArgInfo<T>; + static char const* TryConsumeTo(T& val, char const* args) { - static Optional<std::string_view> TryConsumeTo(T& val, std::string_view args) + return arginfo::TryConsume(val, args); + } +}; + +struct CommandArgsVariantConsumer +{ + template <typename V, typename T1, typename... Ts> + static char const* TryConsumeTo(V& val, char const* args) + { + T1 v; + if (char const* next = CommandArgsConsumerSingle<T1>::TryConsumeTo(v, args)) { - return ArgInfo<T>::TryConsume(val, args); + val = std::move(v); + return next; } - }; + else if constexpr (sizeof...(Ts) > 0) + return TryConsumeTo<V, Ts...>(val, args); + else + return nullptr; + } +}; - template <typename... Ts> - struct SingleConsumer<Trinity::ChatCommands::Variant<Ts...>> +template <typename... Ts> +struct CommandArgsConsumerSingle<Trinity::ChatCommands::Variant<Ts...>> +{ + static char const* TryConsumeTo(Trinity::ChatCommands::Variant<Ts...>& val, char const* args) { - using V = std::variant<Ts...>; - static constexpr size_t N = std::variant_size_v<V>; + return CommandArgsVariantConsumer::TryConsumeTo<Trinity::ChatCommands::Variant<Ts...>, Ts...>(val, args); + } +}; - template <size_t I> - static Optional<std::string_view> TryAtIndex(Trinity::ChatCommands::Variant<Ts...>& val, [[maybe_unused]] std::string_view args) - { - if constexpr (I < N) - { - if (Optional<std::string_view> next = ArgInfo<std::variant_alternative_t<I, V>>::TryConsume(val.template emplace<I>(), args)) - return next; - else - return TryAtIndex<I+1>(val, args); - } - else - return std::nullopt; - } +template <typename T> +struct CommandArgsConsumerSingle<std::vector<T>> +{ + static char const* TryConsumeTo(std::vector<T>& val, char const* args) + { + char const* last; + val.clear(); + + do val.emplace_back(); + while ((args = CommandArgsConsumerSingle<T>::TryConsumeTo(val.back(), (last = args)))); + + val.pop_back(); + return last; + } +}; - static Optional<std::string_view> TryConsumeTo(Trinity::ChatCommands::Variant<Ts...>& val, std::string_view args) +template <typename T, std::size_t C> +struct CommandArgsConsumerSingle<std::array<T, C>> +{ + static char const* TryConsumeTo(std::array<T, C>& val, char const* args) + { + for (T& t : val) { - return TryAtIndex<0>(val, args); + args = CommandArgsConsumerSingle<T>::TryConsumeTo(t, args); + + if (!args) + return nullptr; } - }; - - /* - for backwards compatibility, consumes the rest of the string - new code should use the Tail/WTail tags defined in ChatCommandTags - */ - template <> - struct SingleConsumer<char const*> + + return args; + } +}; + +template <> +struct CommandArgsConsumerSingle<CommandArgs*> +{ + static char const* TryConsumeTo(CommandArgs*&, char const* args) { return args; } +}; + +template <> +struct CommandArgsConsumerSingle<char const*> +{ + static char const* TryConsumeTo(char const*&, char const* args) { return args; } +}; + +template <typename T, size_t offset> +struct CommandArgsConsumerNext; + +template <typename Tuple, typename NextType, size_t offset> +struct CommandArgsConsumerMulti +{ + static char const* TryConsumeTo(Tuple& tuple, char const* args) { - static Optional<std::string_view> TryConsumeTo(char const*& arg, std::string_view args) { arg = args.data(); return std::string_view(); } - }; + if (char const* next = CommandArgsConsumerSingle<NextType>::TryConsumeTo(std::get<offset>(tuple), args)) + return CommandArgsConsumerNext<Tuple, offset+1>::GoNext(tuple, next); + else + return nullptr; + } +}; + +template <typename Tuple, typename NestedNextType, size_t offset> +struct CommandArgsConsumerMulti<Tuple, Optional<NestedNextType>, offset> +{ + static char const* TryConsumeTo(Tuple& tuple, char const* args) + { + // try with the argument + auto& myArg = std::get<offset>(tuple); + myArg.emplace(); + if (char const* next = CommandArgsConsumerSingle<NestedNextType>::TryConsumeTo(myArg.value(), args)) + if ((next = CommandArgsConsumerNext<Tuple, offset+1>::GoNext(tuple, next))) + return next; + // try again omitting the argument + myArg = std::nullopt; + if (char const* next = CommandArgsConsumerNext<Tuple, offset+1>::GoNext(tuple, args)) + return next; + return nullptr; + } +}; +template <size_t offset, typename... Ts> +struct CommandArgsConsumerNext<std::tuple<Ts...>, offset> +{ + using tuple_type = std::tuple<Ts...>; - // forward declaration - // ConsumeFromOffset contains the bounds check for offset, then hands off to MultiConsumer - // the call stack is MultiConsumer -> ConsumeFromOffset -> MultiConsumer -> ConsumeFromOffset etc - // MultiConsumer calls SingleConsumer in each iteration - template <typename Tuple, size_t offset> - Optional<std::string_view> ConsumeFromOffset(Tuple&, std::string_view args); + template <bool C = (offset < sizeof...(Ts))> + static std::enable_if_t<C, char const*> GoNext(tuple_type& tuple, char const* args) + { + return CommandArgsConsumerMulti<tuple_type, std::tuple_element_t<offset, tuple_type>, offset>::TryConsumeTo(tuple, args); + } - template <typename Tuple, typename NextType, size_t offset> - struct MultiConsumer + template <bool C = (offset < sizeof...(Ts))> + static std::enable_if_t<!C, char const*> GoNext(tuple_type&, char const* args) { - static Optional<std::string_view> TryConsumeTo(Tuple& tuple, std::string_view args) + return args; + } +}; + +class TC_GAME_API CommandArgs +{ + public: + CommandArgs(char const* args) : _original(args), _args(args) {} + + template <typename T1, typename T2, typename... Ts> + auto TryConsume() { - if (Optional<std::string_view> next = SingleConsumer<NextType>::TryConsumeTo(std::get<offset>(tuple), args)) - return ConsumeFromOffset<Tuple, offset + 1>(tuple, *next); + Optional<std::tuple<advstd::remove_cvref_t<T1>, advstd::remove_cvref_t<T2>, advstd::remove_cvref_t<Ts>...>> rv; + rv.emplace(); + if (!TryConsumeToTuple<0>(rv.value())) + rv = std::nullopt; + return rv; + } + + template <typename T1> + auto TryConsume() + { + using T = advstd::remove_cvref_t<T1>; + Optional<T> rv; + rv.emplace(); + if (char const* next = CommandArgsConsumerSingle<T>::TryConsumeTo(rv.value(), _args)) + _args = next; else - return std::nullopt; + rv = std::nullopt; + return rv; } - }; - template <typename Tuple, typename NestedNextType, size_t offset> - struct MultiConsumer<Tuple, Optional<NestedNextType>, offset> - { - static Optional<std::string_view> TryConsumeTo(Tuple& tuple, std::string_view args) + template <size_t offset = 0, typename T> + bool TryConsumeToTuple(T& tuple) { - // try with the argument - auto& myArg = std::get<offset>(tuple); - myArg.emplace(); - if (Optional<std::string_view> next = SingleConsumer<NestedNextType>::TryConsumeTo(myArg.value(), args)) - if ((next = ConsumeFromOffset<Tuple, offset + 1>(tuple, *next))) - return next; - // try again omitting the argument - myArg = std::nullopt; - return ConsumeFromOffset<Tuple, offset + 1>(tuple, args); + if (char const* next = CommandArgsConsumerNext<T, offset>::GoNext(tuple, _args)) + { + _args = next; + return true; + } + else + return false; } - }; - template <typename Tuple, size_t offset> - Optional<std::string_view> ConsumeFromOffset(Tuple& tuple, std::string_view args) - { - if constexpr (offset < std::tuple_size_v<Tuple>) - return MultiConsumer<Tuple, std::tuple_element_t<offset, Tuple>, offset>::TryConsumeTo(tuple, args); - else if (!args.empty()) /* the entire string must be consumed */ - return std::nullopt; - else - return args; - } + void Reset() { _args = _original; } + + char const* GetFullArgs() const { return _original; } + char const* GetRemainingArgs() const { return _args; } + + bool IsEmpty() const { return !!*_args; } + explicit operator bool() const { return IsEmpty(); } - template <typename T> struct HandlerToTuple { static_assert(!std::is_same_v<T, T>, "Invalid command handler signature"); }; - template <typename... Ts> struct HandlerToTuple<bool(*)(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; }; - template <typename T> using TupleType = typename HandlerToTuple<T>::type; -} + private: + char const* const _original; + char const* _args; +}; +template <typename T> struct ChatCommandHandlerToTuple { static_assert(!std::is_same_v<T,T>, "Invalid command handler signature"); }; +template <typename... Ts> struct ChatCommandHandlerToTuple<bool(*)(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; }; + +template <typename T> struct ChatCommandStoreLastArg { static void store(T&, CommandArgs&) {} }; +template <> struct ChatCommandStoreLastArg<char const*> { static void store(char const*& arg, CommandArgs& args) { arg = args.GetRemainingArgs(); } }; +template <> struct ChatCommandStoreLastArg<CommandArgs*> { static void store(CommandArgs*& arg, CommandArgs& args) { arg = &args; } }; class TC_GAME_API ChatCommand { @@ -145,12 +238,18 @@ class TC_GAME_API ChatCommand { _wrapper = [](void* handler, ChatHandler* chatHandler, char const* argsStr) { - using Tuple = Trinity::Impl::ChatCommands::TupleType<TypedHandler>; + using tuple_type = typename ChatCommandHandlerToTuple<TypedHandler>::type; - Tuple arguments; + tuple_type arguments; std::get<0>(arguments) = chatHandler; - if (Trinity::Impl::ChatCommands::ConsumeFromOffset<Tuple, 1>(arguments, argsStr)) + + CommandArgs args(argsStr); + if (args.TryConsumeToTuple<1>(arguments)) + { + auto& last = std::get<std::tuple_size_v<tuple_type>-1>(arguments); + ChatCommandStoreLastArg<advstd::remove_cvref_t<decltype(last)>>::store(last, args); return std::apply(reinterpret_cast<TypedHandler>(handler), std::move(arguments)); + } else return false; }; @@ -173,7 +272,7 @@ class TC_GAME_API ChatCommand bool HasHandler() const { return !!_handler; } char const* Name; - uint32 Permission; + uint32 Permission; // function pointer required correct align (use uint32) bool AllowConsole; std::string Help; std::vector<ChatCommand> ChildCommands; diff --git a/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp b/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp index bd3a5d32459..22eabb01613 100644 --- a/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp +++ b/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp @@ -20,7 +20,6 @@ #include "ChatCommand.h" #include "ObjectMgr.h" #include "SpellMgr.h" -#include "Util.h" using namespace Trinity::ChatCommands; @@ -30,13 +29,12 @@ struct AchievementVisitor value_type operator()(Hyperlink<achievement> achData) const { return achData->Achievement; } value_type operator()(uint32 achId) const { return sAchievementMgr->GetAchievement(achId); } }; -Optional<std::string_view> Trinity::Impl::ChatCommands::ArgInfo<AchievementEntry const*>::TryConsume(AchievementEntry const*& data, std::string_view args) +char const* Trinity::ChatCommands::ArgInfo<AchievementEntry const*>::TryConsume(AchievementEntry const*& data, char const* args) { Variant<Hyperlink<achievement>, uint32> val; - Optional<std::string_view> next = SingleConsumer<decltype(val)>::TryConsumeTo(val, args); - if (next) + if ((args = CommandArgsConsumerSingle<decltype(val)>::TryConsumeTo(val, args))) data = val.visit(AchievementVisitor()); - return next; + return args; } struct GameTeleVisitor @@ -45,13 +43,12 @@ struct GameTeleVisitor value_type operator()(Hyperlink<tele> tele) const { return sObjectMgr->GetGameTele(tele); } value_type operator()(std::string const& tele) const { return sObjectMgr->GetGameTele(tele); } }; -Optional<std::string_view> Trinity::Impl::ChatCommands::ArgInfo<GameTele const*>::TryConsume(GameTele const*& data, std::string_view args) +char const* Trinity::ChatCommands::ArgInfo<GameTele const*>::TryConsume(GameTele const*& data, char const* args) { Variant<Hyperlink<tele>, std::string> val; - Optional<std::string_view> next = SingleConsumer<decltype(val)>::TryConsumeTo(val, args); - if (next) + if ((args = CommandArgsConsumerSingle<decltype(val)>::TryConsumeTo(val, args))) data = val.visit(GameTeleVisitor()); - return next; + return args; } struct SpellInfoVisitor @@ -68,25 +65,26 @@ struct SpellInfoVisitor value_type operator()(uint32 spellId) const { return sSpellMgr->GetSpellInfo(spellId); } }; -Optional<std::string_view> Trinity::Impl::ChatCommands::ArgInfo<SpellInfo const*>::TryConsume(SpellInfo const*& data, std::string_view args) +char const* Trinity::ChatCommands::ArgInfo<SpellInfo const*>::TryConsume(SpellInfo const*& data, char const* args) { Variant<Hyperlink<enchant>, Hyperlink<glyph>, Hyperlink<spell>, Hyperlink<talent>, Hyperlink<trade>, uint32> val; - Optional<std::string_view> next = SingleConsumer<decltype(val)>::TryConsumeTo(val, args); - if (next) + if ((args = CommandArgsConsumerSingle<decltype(val)>::TryConsumeTo(val, args))) data = val.visit(SpellInfoVisitor()); - return next; + return args; } -Optional<std::string_view> Trinity::Impl::ChatCommands::ArgInfo<bool>::TryConsume(bool& data, std::string_view args) +char const* Trinity::ChatCommands::ArgInfo<bool>::TryConsume(bool& data, char const* args) { - std::string_view str; - if (Optional<std::string_view> next = SingleConsumer<std::string_view>::TryConsumeTo(str, args)) + std::string val; + if ((args = CommandArgsConsumerSingle<std::string>::TryConsumeTo(val, args))) { - if (Optional<bool> strBool = StringToBool(str)) - { - data = *strBool; - return next; - } + strToLower(val); + if (val == "on" || val == "yes" || val == "true" || val == "1" || val == "y") + data = true; + else if (val == "off" || val == "no" || val == "false" || val == "0" || val == "n") + data = false; + else + return nullptr; } - return std::nullopt; + return args; } diff --git a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h index 4293822699f..ca94835272f 100644 --- a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h +++ b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h @@ -29,15 +29,17 @@ struct GameTele; -namespace Trinity::Impl::ChatCommands +namespace Trinity +{ +namespace ChatCommands { /************************** ARGUMENT HANDLERS *******************************************\ |* Define how to extract contents of a certain requested type from a string *| |* Must implement the following: *| -|* - TryConsume: T&, std::string_view -> Optional<std::string_view> *| -|* returns nullopt if no match, otherwise tail of argument string *| -|* - if nullopt is returned, state of T& is indeterminate *| +|* - TryConsume: T&, char const* -> char const* *| +|* returns nullptr if no match, otherwise pointer to first character of next token *| +|* - if nullptr is returned, state of T& is indeterminate *| |* - otherwise, T& should be initialized to the intended return value *| |* *| \****************************************************************************************/ @@ -48,27 +50,26 @@ struct ArgInfo { static_assert(!std::is_same_v<T,T>, "Invalid command parameter template <typename T> struct ArgInfo<T, std::enable_if_t<std::is_integral_v<T>>> { - static Optional<std::string_view> TryConsume(T& val, std::string_view args) + static char const* TryConsume(T& val, char const* args) { - auto [token, tail] = tokenize(args); - if (token.empty()) - return std::nullopt; + char const* next = args; + std::string_view token(args, Trinity::Impl::ChatCommands::tokenize(next)); if (!token.length()) return nullptr; std::from_chars_result result; - if (StringEqualI(token.substr(0,2), "0x")) + if (StringStartsWith(token, "0x")) result = std::from_chars(token.data() + 2, token.data() + token.length(), val, 16); - else if (StringEqualI(token.substr(0,2), "0b")) + else if (StringStartsWith(token, "0b")) result = std::from_chars(token.data() + 2, token.data() + token.length(), val, 2); else result = std::from_chars(token.data(), token.data() + token.length(), val, 10); if ((token.data() + token.length()) != result.ptr) - return std::nullopt; + return nullptr; - return tail; + return next; } }; @@ -76,26 +77,20 @@ struct ArgInfo<T, std::enable_if_t<std::is_integral_v<T>>> template <typename T> struct ArgInfo<T, std::enable_if_t<std::is_floating_point_v<T>>> { - static Optional<std::string_view> TryConsume(T& val, std::string_view args) + static char const* TryConsume(T& val, char const* args) { - auto [token, tail] = tokenize(args); - if (token.empty()) - return std::nullopt; - + char const* next = args; + std::string token(args, Trinity::Impl::ChatCommands::tokenize(next)); try { // @todo replace this once libc++ supports double args to from_chars for required minimum size_t processedChars = 0; - val = std::stold(std::string(token), &processedChars); + val = std::stold(token, &processedChars); if (processedChars != token.length()) - return std::nullopt; + return nullptr; } - catch (...) { return std::nullopt; } - - if (std::isfinite(val)) - return tail; - else - return std::nullopt; + catch (...) { return nullptr; } + return std::isfinite(val) ? next : nullptr; } }; @@ -103,13 +98,16 @@ struct ArgInfo<T, std::enable_if_t<std::is_floating_point_v<T>>> template <> struct ArgInfo<std::string_view, void> { - static Optional<std::string_view> TryConsume(std::string_view& val, std::string_view args) + static char const* TryConsume(std::string_view& val, char const* args) { - auto [token, next] = tokenize(args); - if (token.empty()) - return std::nullopt; - val = token; - return next; + char const* next = args; + if (size_t len = Trinity::Impl::ChatCommands::tokenize(next)) + { + val = std::string_view(args, len); + return next; + } + else + return nullptr; } }; @@ -117,13 +115,13 @@ struct ArgInfo<std::string_view, void> template <> struct ArgInfo<std::string, void> { - static Optional<std::string_view> TryConsume(std::string& val, std::string_view args) + static char const* TryConsume(std::string& val, char const* args) { std::string_view view; - Optional<std::string_view> next = ArgInfo<std::string_view>::TryConsume(view, args); - if (next) + args = ArgInfo<std::string_view>::TryConsume(view, args); + if (args) val.assign(view); - return next; + return args; } }; @@ -131,15 +129,18 @@ struct ArgInfo<std::string, void> template <> struct ArgInfo<std::wstring, void> { - static Optional<std::string_view> TryConsume(std::wstring& val, std::string_view args) + static char const* TryConsume(std::wstring& val, char const* args) { std::string_view utf8view; - Optional<std::string_view> next = ArgInfo<std::string_view>::TryConsume(utf8view, args); + char const* ret = ArgInfo<std::string_view>::TryConsume(utf8view, args); - if (next && Utf8toWStr(utf8view, val)) - return next; - else - return std::nullopt; + if (!ret) + return nullptr; + + if (!Utf8toWStr(utf8view, val)) + return nullptr; + + return ret; } }; @@ -197,31 +198,32 @@ struct ArgInfo<T, std::enable_if_t<std::is_enum_v<T>>> return nullptr; } - static Optional<std::string_view> TryConsume(T& val, std::string_view args) + static char const* TryConsume(T& val, char const* args) { std::string strVal; - Optional<std::string_view> next = ArgInfo<std::string>::TryConsume(strVal, args); + char const* ret = ArgInfo<std::string>::TryConsume(strVal, args); + + if (!ret) + return nullptr; - if (next) + if (T const* tmpVal = Match(strVal)) { - if (T const* match = Match(strVal)) - { - val = *match; - return next; - } + val = *tmpVal; + return ret; } // Value not found. Try to parse arg as underlying type and cast it to enum type using U = std::underlying_type_t<T>; U uVal = 0; - next = ArgInfo<U>::TryConsume(uVal, args); - if (next && EnumUtils::IsValid<T>(uVal)) + ret = ArgInfo<U>::TryConsume(uVal, args); + if (ret) { val = static_cast<T>(uVal); - return next; + if (!EnumUtils::IsValid(val)) + return nullptr; } - return std::nullopt; + return ret; } }; @@ -229,70 +231,41 @@ struct ArgInfo<T, std::enable_if_t<std::is_enum_v<T>>> template <typename T> struct ArgInfo<T, std::enable_if_t<std::is_base_of_v<ContainerTag, T>>> { - static Optional<std::string_view> TryConsume(T& tag, std::string_view args) + static char const* TryConsume(T& tag, char const* args) { return tag.TryConsume(args); } }; -template <typename T> -struct ArgInfo<std::vector<T>, void> -{ - static Optional<std::string_view> TryConsume(std::vector<T>& val, std::string_view args) - { - val.clear(); - Optional<std::string_view> next = ArgInfo<T>::TryConsume(val.emplace_back(), args); - - if (!next) - return std::nullopt; - - while (Optional<std::string_view> next2 = ArgInfo<T>::TryConsume(val.emplace_back(), *next)) - next = next2; - return next; - } -}; - -template <typename T, size_t N> -struct ArgInfo<std::array<T, N>, void> -{ - static Optional<std::string_view> TryConsume(std::array<T, N>& val, std::string_view args) - { - Optional<std::string_view> next = args; - for (T& t : val) - if (!(next = ArgInfo<T>::TryConsume(t, *next))) - return std::nullopt; - return next; - } -}; - // AchievementEntry* from numeric id or link template <> struct TC_GAME_API ArgInfo<AchievementEntry const*> { - static Optional<std::string_view> TryConsume(AchievementEntry const*&, std::string_view); + static char const* TryConsume(AchievementEntry const*&, char const*); }; // GameTele* from string name or link template <> struct TC_GAME_API ArgInfo<GameTele const*> { - static Optional<std::string_view> TryConsume(GameTele const*&, std::string_view); + static char const* TryConsume(GameTele const*&, char const*); }; // SpellInfo const* from spell id or link template <> struct TC_GAME_API ArgInfo<SpellInfo const*> { - static Optional<std::string_view> TryConsume(SpellInfo const*&, std::string_view); + static char const* TryConsume(SpellInfo const*&, char const*); }; -// bool from string +// bool from 1/0 or on/off template <> struct TC_GAME_API ArgInfo<bool> { - static Optional<std::string_view> TryConsume(bool&, std::string_view); + static char const* TryConsume(bool&, char const*); }; } +} #endif diff --git a/src/server/game/Chat/ChatCommands/ChatCommandHelpers.h b/src/server/game/Chat/ChatCommands/ChatCommandHelpers.h index c6cf4f8ad94..e22823e5d35 100644 --- a/src/server/game/Chat/ChatCommands/ChatCommandHelpers.h +++ b/src/server/game/Chat/ChatCommands/ChatCommandHelpers.h @@ -18,15 +18,10 @@ #ifndef TRINITY_CHATCOMMANDHELPERS_H #define TRINITY_CHATCOMMANDHELPERS_H -#include <string_view> #include <type_traits> -namespace Trinity::Impl::ChatCommands +namespace Trinity::ChatCommands { - /***************** HELPERS *************************\ - |* These really aren't for outside use... *| - \***************************************************/ - static constexpr char COMMAND_DELIMITER = ' '; template <typename T, typename = void> @@ -37,26 +32,19 @@ namespace Trinity::Impl::ChatCommands template <typename T> using tag_base_t = typename tag_base<T>::type; +} - struct TokenizeResult { - explicit operator bool() { return !token.empty(); } - std::string_view token; - std::string_view tail; - }; - - inline TokenizeResult tokenize(std::string_view args) +namespace Trinity::Impl::ChatCommands +{ + /***************** HELPERS *************************\ + |* These really aren't for outside use... *| + \***************************************************/ + inline std::size_t tokenize(char const*& end) { - TokenizeResult result; - if (size_t delimPos = args.find(COMMAND_DELIMITER); delimPos != std::string_view::npos) - { - result.token = args.substr(0, delimPos); - if (size_t tailPos = args.find_first_not_of(COMMAND_DELIMITER, delimPos); tailPos != std::string_view::npos) - result.tail = args.substr(tailPos); - } - else - result.token = args; - - return result; + std::size_t len = 0; + for (; *end && *end != Trinity::ChatCommands::COMMAND_DELIMITER; ++end, ++len); + for (; *end && *end == Trinity::ChatCommands::COMMAND_DELIMITER; ++end); + return len; } template <typename T, typename... Ts> diff --git a/src/server/game/Chat/ChatCommands/ChatCommandTags.h b/src/server/game/Chat/ChatCommands/ChatCommandTags.h index 6e150b62e8e..22db765f102 100644 --- a/src/server/game/Chat/ChatCommands/ChatCommandTags.h +++ b/src/server/game/Chat/ChatCommands/ChatCommandTags.h @@ -22,95 +22,59 @@ #include "ChatCommandHelpers.h" #include "Hyperlinks.h" #include "Optional.h" -#include "Util.h" #include <cmath> #include <cstring> #include <iostream> #include <string> -#include <string_view> #include <tuple> #include <type_traits> #include <utility> #include <variant> -namespace Trinity::Impl::ChatCommands -{ - struct ContainerTag {}; - template <typename T> - struct tag_base<T, std::enable_if_t<std::is_base_of_v<ContainerTag, T>>> - { - using type = typename T::value_type; - }; -} - namespace Trinity::ChatCommands { /************************** CONTAINER TAGS **********************************************\ |* Simple holder classes to differentiate between extraction methods *| - |* Must inherit from Trinity::Impl::ChatCommands::ContainerTag *| + |* Should inherit from ContainerTag for template identification *| |* Must implement the following: *| - |* - TryConsume: std::string_view -> Optional<std::string_view> *| - |* returns nullopt if no match, otherwise the tail of the provided argument string *| + |* - TryConsume: char const* -> char const* *| + |* returns nullptr if no match, otherwise pointer to first character of next token *| |* - typedef value_type of type that is contained within the tag *| |* - cast operator to value_type *| |* *| \****************************************************************************************/ + struct ContainerTag {}; + template <typename T> + struct tag_base<T, std::enable_if_t<std::is_base_of_v<ContainerTag, T>>> + { + using type = typename T::value_type; + }; template <char c1, char... chars> - struct ExactSequence : Trinity::Impl::ChatCommands::ContainerTag + struct ExactSequence : public ContainerTag { using value_type = void; - static constexpr size_t N = (sizeof...(chars) + 1); - - static bool Match(char const* pos) - { - if (*(pos++) != c1) - return false; - else if constexpr (sizeof...(chars) > 0) - return ExactSequence<chars...>::Match(pos); - else - return true; - } - - Optional<std::string_view> TryConsume(std::string_view args) const + static char const* _TryConsume(char const* pos) { - if ((N <= args.length()) && ExactSequence::Match(args.data())) + if (*(pos++) == c1) { - auto [remainingToken, tail] = Trinity::Impl::ChatCommands::tokenize(args.substr(N)); - if (remainingToken.empty()) // if this is not empty, then we did not consume the full token - return tail; + if constexpr (sizeof...(chars) > 0) + return ExactSequence<chars...>::_TryConsume(pos); + else if (Trinity::Impl::ChatCommands::tokenize(pos)) /* we did not consume the entire token */ + return nullptr; + else + return pos; } - return std::nullopt; - } - }; - - struct Tail : std::string_view, Trinity::Impl::ChatCommands::ContainerTag - { - using value_type = std::string_view; - - Optional<std::string_view> TryConsume(std::string_view args) - { - std::string_view::operator=(args); - return std::string_view(); - } - }; - - struct WTail : std::wstring, Trinity::Impl::ChatCommands::ContainerTag - { - using value_type = std::wstring; - - Optional<std::string_view> TryConsume(std::string_view args) - { - if (Utf8toWStr(args, *this)) - return std::string_view(); else - return std::nullopt; + return nullptr; } + + char const* TryConsume(char const* pos) const { return ExactSequence::_TryConsume(pos); } }; template <typename linktag> - struct Hyperlink : Trinity::Impl::ChatCommands::ContainerTag + struct Hyperlink : public ContainerTag { using value_type = typename linktag::value_type; using storage_type = advstd::remove_cvref_t<value_type>; @@ -120,27 +84,29 @@ namespace Trinity::ChatCommands value_type operator*() const { return val; } storage_type const* operator->() const { return &val; } - Optional<std::string_view> TryConsume(std::string_view args) + char const* TryConsume(char const* pos) { - Trinity::Hyperlinks::HyperlinkInfo info = Trinity::Hyperlinks::ParseSingleHyperlink(args); + Trinity::Hyperlinks::HyperlinkInfo info = Trinity::Hyperlinks::ParseHyperlink(pos); // invalid hyperlinks cannot be consumed if (!info) - return std::nullopt; + return nullptr; // check if we got the right tag - if (info.tag != linktag::tag()) - return std::nullopt; + if (info.tag.second != strlen(linktag::tag())) + return nullptr; + if (strncmp(info.tag.first, linktag::tag(), strlen(linktag::tag())) != 0) + return nullptr; // store value - if (!linktag::StoreTo(val, info.data)) - return std::nullopt; + if (!linktag::StoreTo(val, info.data.first, info.data.second)) + return nullptr; - // finally, skip any potential delimiters - auto [token, next] = Trinity::Impl::ChatCommands::tokenize(info.tail); - if (token.empty()) /* empty token = first character is delimiter, skip past it */ - return next; - else - return info.tail; + // finally, skip to end of token + pos = info.next; + Trinity::Impl::ChatCommands::tokenize(pos); + + // return final pos + return pos; } private: @@ -171,8 +137,8 @@ namespace Trinity::ChatCommands { using base = std::variant<T1, Ts...>; - using first_type = Trinity::Impl::ChatCommands::tag_base_t<T1>; - static constexpr bool have_operators = Trinity::Impl::ChatCommands::are_all_assignable<first_type, Trinity::Impl::ChatCommands::tag_base_t<Ts>...>::value; + using first_type = tag_base_t<T1>; + static constexpr bool have_operators = Trinity::Impl::ChatCommands::are_all_assignable<first_type, tag_base_t<Ts>...>::value; template <bool C = have_operators> std::enable_if_t<C, first_type> operator*() const |