Acore::Impl::ChatCommands::ChatCommandNode Class Reference

#include "ChatCommand.h"

Public Member Functions
	ChatCommandNode ()

Static Public Member Functions
static void	LoadCommandMap ()
static void	InvalidateCommandMap ()
static bool	TryExecuteCommand (ChatHandler &handler, std::string_view cmd)
static void	SendCommandHelpFor (ChatHandler &handler, std::string_view cmd)
static std::vector< std::string >	GetAutoCompletionsFor (ChatHandler const &handler, std::string_view cmd)

Private Types
using	ChatCommandBuilder = Acore::ChatCommands::ChatCommandBuilder

Private Member Functions
void	LoadFromBuilder (ChatCommandBuilder const &builder)
	ChatCommandNode (ChatCommandNode &&other)=default
void	ResolveNames (std::string name)
void	SendCommandHelp (ChatHandler &handler) const
bool	IsVisible (ChatHandler const &who) const
bool	IsInvokerVisible (ChatHandler const &who) const
bool	HasVisibleSubCommands (ChatHandler const &who) const

Static Private Member Functions
static std::map< std::string_view, ChatCommandNode, StringCompareLessI_T > const &	GetTopLevelMap ()
static void	LoadCommandsIntoMap (ChatCommandNode *blank, std::map< std::string_view, Acore::Impl::ChatCommands::ChatCommandNode, StringCompareLessI_T > &map, Acore::ChatCommands::ChatCommandTable const &commands)

Private Attributes
std::string	_name
CommandInvoker	_invoker
CommandPermissions	_permission
std::variant< std::monostate, AcoreStrings, std::string >	_help
std::map< std::string_view, ChatCommandNode, StringCompareLessI_T >	_subCommands

Friends
struct	FilteredCommandListIterator

Detailed Description

Member Typedef Documentation

ChatCommandBuilder

using Acore::Impl::ChatCommands::ChatCommandNode::ChatCommandBuilder = Acore::ChatCommands::ChatCommandBuilder

private

Constructor & Destructor Documentation

ChatCommandNode() [1/2]

Acore::Impl::ChatCommands::ChatCommandNode::ChatCommandNode ( )

inline

: _name{}, _invoker {}, _permission{}, _help{}, _subCommands{} { }

ChatCommandNode() [2/2]

Acore::Impl::ChatCommands::ChatCommandNode::ChatCommandNode ( ChatCommandNode &&  other )

privatedefault

Member Function Documentation

GetAutoCompletionsFor()

std::vector< std::string > Acore::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor ( ChatHandler const &  handler, std::string_view  cmd  )

static

{
    std::string path;
    ChatCommandNode const* cmd = nullptr;
    ChatSubCommandMap const* map = &GetTopLevelMap();
 
    while (!cmdStr.empty() && (cmdStr.front() == COMMAND_DELIMITER))
        cmdStr.remove_prefix(1);
 
    while (!cmdStr.empty() && (cmdStr.back() == COMMAND_DELIMITER))
        cmdStr.remove_suffix(1);
 
    std::string_view oldTail = cmdStr;
    while (!oldTail.empty())
    {
        /* oldTail = token DELIMITER newTail */
        auto [token, newTail] = tokenize(oldTail);
        ASSERT(!token.empty());
        FilteredCommandListIterator it1(*map, handler, token);
        if (!it1)
            break; /* no matching subcommands found */
 
        if (!StringEqualI(it1->first, token))
        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
            auto it2 = it1;
            ++it2;
 
            if (it2)
            { /* there are multiple matching subcommands - terminate here and show possibilities */
                std::vector<std::string> vec;
                auto possibility = ([prefix = std::string_view(path), suffix = std::string_view(newTail)](std::string_view match)
                {
                    if (prefix.empty())
                    {
                        return Acore::StringFormat("{}{}{}", match, COMMAND_DELIMITER, suffix);
                    }
                    else
                    {
                        return Acore::StringFormat("{}{}{}{}{}", prefix, COMMAND_DELIMITER, match, COMMAND_DELIMITER, suffix);
                    }
                });
 
                vec.emplace_back(possibility(it1->first));
 
                do vec.emplace_back(possibility(it2->first));
                while (++it2);
 
                return vec;
            }
        }
 
        /* now we matched exactly one subcommand, and it1 points to it; go down the rabbit hole */
        if (path.empty())
            path.assign(it1->first);
        else
        {
            path = Acore::StringFormat("{}{}{}", path, COMMAND_DELIMITER, it1->first);
        }
        cmd = &it1->second;
        map = &cmd->_subCommands;
 
        oldTail = newTail;
    }
 
    if (!oldTail.empty())
    { /* there is some trailing text, leave it as is */
        if (cmd)
        { /* if we matched a command at some point, auto-complete it */
            return { Acore::StringFormat("{}{}{}", path, COMMAND_DELIMITER, oldTail) };
        }
        else
            return {};
    }
    else
    { /* offer all subcommands */
        auto possibility = ([prefix = std::string_view(path)](std::string_view match)
        {
            if (prefix.empty())
                return std::string(match);
            else
            {
                return Acore::StringFormat("{}{}{}", prefix, COMMAND_DELIMITER, match);
            }
        });
 
        std::vector<std::string> vec;
        for (FilteredCommandListIterator it(*map, handler, ""); it; ++it)
            vec.emplace_back(possibility(it->first));
        return vec;
    }
}

References _subCommands, ASSERT, Acore::Impl::ChatCommands::COMMAND_DELIMITER, StringEqualI(), Acore::StringFormat(), and Acore::Impl::ChatCommands::tokenize().

Referenced by Acore::ChatCommands::GetAutoCompletionsFor().

GetTopLevelMap()

ChatSubCommandMap const & Acore::Impl::ChatCommands::ChatCommandNode::GetTopLevelMap ( )

staticprivate

{
    if (COMMAND_MAP.empty())
        LoadCommandMap();
 
    return COMMAND_MAP;
}

References COMMAND_MAP.

HasVisibleSubCommands()

bool Acore::Impl::ChatCommands::ChatCommandNode::HasVisibleSubCommands ( ChatHandler const &  who ) const

private

{
    for (auto it = _subCommands.begin(); it != _subCommands.end(); ++it)
        if (it->second.IsVisible(who))
            return true;
 
    return false;
}

Referenced by IsVisible().

InvalidateCommandMap()

void Acore::Impl::ChatCommands::ChatCommandNode::InvalidateCommandMap ( )

static

{
    COMMAND_MAP.clear();
}

References COMMAND_MAP.

Referenced by Acore::ChatCommands::InvalidateCommandMap().

IsInvokerVisible()

bool Acore::Impl::ChatCommands::ChatCommandNode::IsInvokerVisible ( ChatHandler const &  who ) const

private

{
    if (!_invoker)
        return false;
 
    if (!sScriptMgr->OnBeforeIsInvokerVisible(_name, _permission, who))
        return true;
 
    if (who.IsConsole() && (_permission.AllowConsole == Acore::ChatCommands::Console::No))
        return false;
 
    if (who.IsConsole() && (_permission.AllowConsole == Acore::ChatCommands::Console::Yes))
        return true;
 
    return !who.IsConsole() && who.IsAvailable(_permission.RequiredLevel);
}

References ChatHandler::IsAvailable(), ChatHandler::IsConsole(), Acore::ChatCommands::No, sScriptMgr, and Acore::ChatCommands::Yes.

Referenced by IsVisible(), and TryExecuteCommand().

IsVisible()

bool Acore::Impl::ChatCommands::ChatCommandNode::IsVisible ( ChatHandler const &  who ) const

inlineprivate

{ return (IsInvokerVisible(who) || HasVisibleSubCommands(who)); }

References HasVisibleSubCommands(), and IsInvokerVisible().

LoadCommandMap()

void Acore::Impl::ChatCommands::ChatCommandNode::LoadCommandMap ( )

static

{
    InvalidateCommandMap();
    LoadCommandsIntoMap(nullptr, COMMAND_MAP, sScriptMgr->GetChatCommands());
 
    if (PreparedQueryResult result = WorldDatabase.Query(WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS)))
    {
        do
        {
            Field* fields = result->Fetch();
            std::string_view const name = fields[0].Get<std::string_view>();
            std::string_view const help = fields[2].Get<std::string_view>();
            uint32 const secLevel = fields[1].Get<uint8>();
 
            ChatCommandNode* cmd = nullptr;
            ChatSubCommandMap* map = &COMMAND_MAP;
 
            for (std::string_view key : Acore::Tokenize(name, COMMAND_DELIMITER, false))
            {
                auto it = map->find(key);
                if (it != map->end())
                {
                    cmd = &it->second;
                    map = &cmd->_subCommands;
                }
                else
                {
                    LOG_ERROR("sql.sql", "Table `command` contains data for non-existant command '{}'. Skipped.", name);
                    cmd = nullptr;
                    break;
                }
            }
 
            if (!cmd)
                continue;
 
            if (cmd->_invoker && (cmd->_permission.RequiredLevel != secLevel))
            {
                LOG_WARN("sql.sql", "Table `command` has permission {} for '{}' which does not match the core ({}). Overriding.",
                    secLevel, name, cmd->_permission.RequiredLevel);
 
                cmd->_permission.RequiredLevel = secLevel;
            }
 
            if (std::holds_alternative<std::string>(cmd->_help))
                LOG_ERROR("sql.sql", "Table `command` contains duplicate data for command '{}'. Skipped.", name);
 
            if (std::holds_alternative<std::monostate>(cmd->_help))
                cmd->_help.emplace<std::string>(help);
            else
                LOG_ERROR("sql.sql", "Table `command` contains legacy help text for command '{}', which uses `acore_string`. Skipped.", name);
        } while (result->NextRow());
    }
 
    for (auto& [name, cmd] : COMMAND_MAP)
        cmd.ResolveNames(std::string(name));
}

References Acore::Impl::ChatCommands::COMMAND_DELIMITER, COMMAND_MAP, Field::Get(), LOG_ERROR, LOG_WARN, sScriptMgr, Acore::Tokenize(), WORLD_SEL_COMMANDS, and WorldDatabase.

Referenced by Acore::ChatCommands::LoadCommandMap().

LoadCommandsIntoMap()

void Acore::Impl::ChatCommands::ChatCommandNode::LoadCommandsIntoMap ( ChatCommandNode *  blank, std::map< std::string_view, Acore::Impl::ChatCommands::ChatCommandNode, StringCompareLessI_T > &  map, Acore::ChatCommands::ChatCommandTable const &  commands  )

staticprivate

{
    for (ChatCommandBuilder const& builder : commands)
    {
        if (builder._name.empty())
        {
            ASSERT(blank, "Empty name command at top level is not permitted.");
            blank->LoadFromBuilder(builder);
        }
        else
        {
            std::vector<std::string_view> const tokens = Acore::Tokenize(builder._name, COMMAND_DELIMITER, false);
            ASSERT(!tokens.empty(), "Invalid command name '{}'.", builder._name);
            ChatSubCommandMap* subMap = &map;
            for (std::size_t i = 0, n = (tokens.size() - 1); i < n; ++i)
                subMap = &((*subMap)[tokens[i]]._subCommands);
            ((*subMap)[tokens.back()]).LoadFromBuilder(builder);
        }
    }
}

References ASSERT, Acore::Impl::ChatCommands::COMMAND_DELIMITER, LoadFromBuilder(), and Acore::Tokenize().

Referenced by LoadFromBuilder().

LoadFromBuilder()

void Acore::Impl::ChatCommands::ChatCommandNode::LoadFromBuilder ( ChatCommandBuilder const &  builder )

private

{
    if (std::holds_alternative<ChatCommandBuilder::InvokerEntry>(builder._data))
    {
        ASSERT(!_invoker, "Duplicate blank sub-command.");
        AcoreStrings help;
        std::tie(_invoker, help, _permission) = *(std::get<ChatCommandBuilder::InvokerEntry>(builder._data));
        if (help)
            _help.emplace<AcoreStrings>(help);
    }
    else
        LoadCommandsIntoMap(this, _subCommands, std::get<ChatCommandBuilder::SubCommandEntry>(builder._data));
}

References Acore::ChatCommands::ChatCommandBuilder::_data, _help, _invoker, _permission, _subCommands, ASSERT, and LoadCommandsIntoMap().

Referenced by LoadCommandsIntoMap().

ResolveNames()

void Acore::Impl::ChatCommands::ChatCommandNode::ResolveNames ( std::string  name )

private

{
    if (_invoker && std::holds_alternative<std::monostate>(_help))
        LOG_WARN("sql.sql", "Table `command` is missing help text for command '{}'.", name);
 
    _name = name;
 
    for (auto& [subToken, cmd] : _subCommands)
    {
        std::string subName(name);
        subName.push_back(COMMAND_DELIMITER);
        subName.append(subToken);
        cmd.ResolveNames(subName);
    }
}

References Acore::Impl::ChatCommands::COMMAND_DELIMITER, and LOG_WARN.

SendCommandHelp()

void Acore::Impl::ChatCommands::ChatCommandNode::SendCommandHelp ( ChatHandler &  handler ) const

private

{
    bool const hasInvoker = IsInvokerVisible(handler);
    if (hasInvoker)
    {
        if (std::holds_alternative<AcoreStrings>(_help))
            handler.SendSysMessage(std::get<AcoreStrings>(_help));
        else if (std::holds_alternative<std::string>(_help))
            handler.SendSysMessage(std::get<std::string>(_help));
        else
        {
            handler.PSendSysMessage(LANG_CMD_HELP_GENERIC, _name);
            handler.PSendSysMessage(LANG_CMD_NO_HELP_AVAILABLE, _name);
        }
    }
 
    bool header = false;
 
    for (auto it = _subCommands.begin(); it != _subCommands.end(); ++it)
    {
        bool const subCommandHasSubCommand = it->second.HasVisibleSubCommands(handler);
 
        if (!subCommandHasSubCommand && !it->second.IsInvokerVisible(handler))
        {
            continue;
        }
 
        if (!header)
        {
            if (!hasInvoker)
            {
                handler.PSendSysMessage(LANG_CMD_HELP_GENERIC, _name);
            }
 
            handler.SendSysMessage(LANG_SUBCMDS_LIST);
            header = true;
        }
 
        handler.PSendSysMessage(subCommandHasSubCommand ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, it->second._name);
    }
}

References LANG_CMD_HELP_GENERIC, LANG_CMD_NO_HELP_AVAILABLE, LANG_SUBCMDS_LIST, LANG_SUBCMDS_LIST_ENTRY, LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS, ChatHandler::PSendSysMessage(), and ChatHandler::SendSysMessage().

Referenced by SendCommandHelpFor(), and TryExecuteCommand().

SendCommandHelpFor()

void Acore::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor ( ChatHandler &  handler, std::string_view  cmd  )

static

{
    ChatCommandNode const* cmd = nullptr;
    ChatSubCommandMap const* map = &GetTopLevelMap();
 
    for (std::string_view token : Acore::Tokenize(cmdStr, COMMAND_DELIMITER, false))
    {
        FilteredCommandListIterator it1(*map, handler, token);
        if (!it1)
        { /* no matching subcommands found */
            if (cmd)
            {
                cmd->SendCommandHelp(handler);
                handler.PSendSysMessage(LANG_SUBCMD_INVALID, cmd->_name, COMMAND_DELIMITER, token);
            }
            else
                handler.PSendSysMessage(LANG_CMD_INVALID, token);
            return;
        }
 
        if (!StringEqualI(it1->first, token))
        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
            auto it2 = it1;
            ++it2;
 
            if (it2)
            { /* there are multiple matching subcommands - print possibilities and return */
                if (cmd)
                    handler.PSendSysMessage(LANG_SUBCMD_AMBIGUOUS, cmd->_name, COMMAND_DELIMITER, token);
                else
                    handler.PSendSysMessage(LANG_CMD_AMBIGUOUS, token);
 
                handler.PSendSysMessage(it1->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, it1->first);
                do
                {
                    handler.PSendSysMessage(it2->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, it2->first);
                } while (++it2);
 
                return;
            }
        }
 
        cmd = &it1->second;
        map = &cmd->_subCommands;
    }
 
    if (cmd)
        cmd->SendCommandHelp(handler);
    else if (cmdStr.empty())
    {
        FilteredCommandListIterator it(*map, handler, "");
        if (!it)
            return;
        handler.SendSysMessage(LANG_AVAILABLE_CMDS);
        do
        {
            handler.PSendSysMessage(it->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, it->second._name);
        } while (++it);
    }
    else
        handler.PSendSysMessage(LANG_CMD_INVALID, cmdStr);
}

References _name, _subCommands, Acore::Impl::ChatCommands::COMMAND_DELIMITER, LANG_AVAILABLE_CMDS, LANG_CMD_AMBIGUOUS, LANG_CMD_INVALID, LANG_SUBCMD_AMBIGUOUS, LANG_SUBCMD_INVALID, LANG_SUBCMDS_LIST_ENTRY, LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS, ChatHandler::PSendSysMessage(), SendCommandHelp(), ChatHandler::SendSysMessage(), StringEqualI(), and Acore::Tokenize().

Referenced by Acore::ChatCommands::SendCommandHelpFor().

TryExecuteCommand()

bool Acore::Impl::ChatCommands::ChatCommandNode::TryExecuteCommand ( ChatHandler &  handler, std::string_view  cmd  )

static

{
    ChatCommandNode const* cmd = nullptr;
    ChatSubCommandMap const* map = &GetTopLevelMap();
 
    while (!cmdStr.empty() && (cmdStr.front() == COMMAND_DELIMITER))
        cmdStr.remove_prefix(1);
 
    while (!cmdStr.empty() && (cmdStr.back() == COMMAND_DELIMITER))
        cmdStr.remove_suffix(1);
 
    std::string_view oldTail = cmdStr;
    while (!oldTail.empty())
    {
        /* oldTail = token DELIMITER newTail */
        auto [token, newTail] = tokenize(oldTail);
        ASSERT(!token.empty());
 
        FilteredCommandListIterator it1(*map, handler, token);
        if (!it1)
            break; /* no matching subcommands found */
 
        if (!StringEqualI(it1->first, token))
        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
            auto it2 = it1;
            ++it2;
 
            if (it2)
            { /* there are multiple matching subcommands - print possibilities and return */
                if (cmd)
                    handler.PSendSysMessage(LANG_SUBCMD_AMBIGUOUS, cmd->_name, COMMAND_DELIMITER, token);
                else
                    handler.PSendSysMessage(LANG_CMD_AMBIGUOUS, token);
 
                handler.PSendSysMessage(it1->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, it1->first);
                do
                {
                    handler.PSendSysMessage(it2->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, it2->first);
                } while (++it2);
 
                return true;
            }
        }
 
        /* now we matched exactly one subcommand, and it1 points to it; go down the rabbit hole */
        cmd = &it1->second;
        map = &cmd->_subCommands;
 
        oldTail = newTail;
    }
 
    if (!sScriptMgr->OnTryExecuteCommand(handler, cmdStr))
        return true;
 
    /* if we matched a command at some point, invoke it */
    if (cmd)
    {
        handler.SetSentErrorMessage(false);
        if (cmd->IsInvokerVisible(handler) && cmd->_invoker(&handler, oldTail))
        { /* invocation succeeded, log this */
            if (!handler.IsConsole())
                LogCommandUsage(*handler.GetSession(), cmdStr);
        }
        else if (!handler.HasSentErrorMessage()) /* invocation failed, we should show usage */
        {
            cmd->SendCommandHelp(handler);
            handler.SetSentErrorMessage(true);
        }
 
        return true;
    }
 
    return false;
}

References _invoker, _name, _subCommands, ASSERT, Acore::Impl::ChatCommands::COMMAND_DELIMITER, ChatHandler::GetSession(), ChatHandler::HasSentErrorMessage(), ChatHandler::IsConsole(), IsInvokerVisible(), LANG_CMD_AMBIGUOUS, LANG_SUBCMD_AMBIGUOUS, LANG_SUBCMDS_LIST_ENTRY, LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS, LogCommandUsage(), ChatHandler::PSendSysMessage(), SendCommandHelp(), ChatHandler::SetSentErrorMessage(), sScriptMgr, StringEqualI(), and Acore::Impl::ChatCommands::tokenize().

Referenced by Acore::ChatCommands::TryExecuteCommand().

Friends And Related Function Documentation

FilteredCommandListIterator

friend struct FilteredCommandListIterator

friend

Member Data Documentation

_help

std::variant<std::monostate, AcoreStrings, std::string> Acore::Impl::ChatCommands::ChatCommandNode::_help

private

Referenced by LoadFromBuilder().

_invoker

CommandInvoker Acore::Impl::ChatCommands::ChatCommandNode::_invoker

private

Referenced by LoadFromBuilder(), and TryExecuteCommand().

_name

std::string Acore::Impl::ChatCommands::ChatCommandNode::_name

private

Referenced by SendCommandHelpFor(), and TryExecuteCommand().

_permission

CommandPermissions Acore::Impl::ChatCommands::ChatCommandNode::_permission

private

Referenced by LoadFromBuilder().

_subCommands

std::map<std::string_view, ChatCommandNode, StringCompareLessI_T> Acore::Impl::ChatCommands::ChatCommandNode::_subCommands

private

Referenced by GetAutoCompletionsFor(), LoadFromBuilder(), SendCommandHelpFor(), and TryExecuteCommand().