d4/dea/CommandManager_8cpp_source.html

#include "CommandManager.hpp"

#include "Client.hpp"

#include "Replies.hpp"

#include "Server.hpp"

#include <algorithm>

#include <iostream>

#include <sstream>


// Include all concrete command headers

#include "InviteCommand.hpp"

#include "JoinCommand.hpp"

#include "KickCommand.hpp"

#include "ListCommand.hpp"

#include "ModeCommand.hpp"

#include "NamesCommand.hpp"

#include "NickCommand.hpp"

#include "NoticeCommand.hpp"

#include "PartCommand.hpp"

#include "PassCommand.hpp"

#include "PingCommand.hpp"

#include "PongCommand.hpp"

#include "PrivmsgCommand.hpp"

#include "QuitCommand.hpp"

#include "TopicCommand.hpp"

#include "UserCommand.hpp"

#include "WhoCommand.hpp"

#include "WhoisCommand.hpp"


CommandManager::CommandManager(Server *server) : _server(server) {

    _commands["PASS"] = new PassCommand(server);

    _commands["NICK"] = new NickCommand(server);

    _commands["USER"] = new UserCommand(server);

    _commands["JOIN"] = new JoinCommand(server);

    _commands["PRIVMSG"] = new PrivmsgCommand(server);

    _commands["PART"] = new PartCommand(server);

    _commands["QUIT"] = new QuitCommand(server);

    _commands["PING"] = new PingCommand(server);

    _commands["PONG"] = new PongCommand(server);

    _commands["NOTICE"] = new NoticeCommand(server);

    _commands["NAMES"] = new NamesCommand(server);

    _commands["TOPIC"] = new TopicCommand(server);

    _commands["MODE"] = new ModeCommand(server);

    _commands["KICK"] = new KickCommand(server);

    _commands["LIST"] = new ListCommand(server);

    _commands["WHO"] = new WhoCommand(server);

    _commands["WHOIS"] = new WhoisCommand(server);

    _commands["INVITE"] = new InviteCommand(server);

}


CommandManager::~CommandManager() {

    for (std::map<std::string, ICommand *>::iterator it = _commands.begin(); it != _commands.end(); ++it) {

        delete it->second;

    }

}


std::string CommandManager::getCommand(const std::string &rawMessage) {

    std::string command;

    size_t start = 0;

    // Skip prefix if it exists

    if (rawMessage[0] == ':') {

        start = rawMessage.find(' ');

        if (start == std::string::npos)

            return ""; // Malformed message

        start++;       // Move past the space

    }


    size_t end = rawMessage.find(' ', start);

    if (end == std::string::npos) {

        command = rawMessage.substr(start);

    } else {

        command = rawMessage.substr(start, end - start);

    }

    // --------- debug ---------

    // std::cout << "rawMessage[" << rawMessage << "]" << std::endl;

    // std::cout << "start[" << start << "]" << std::endl;

    // std::cout << "end[" << end << "]" << std::endl;

    // std::cout << "command[" << command << "]" << std::endl;

    // -------------------------

    std::transform(command.begin(), command.end(), command.begin(), ::toupper);

    return command;

}


std::vector<std::string> CommandManager::getArguments(const std::string &rawMessage) {

    std::vector<std::string> args;

    std::stringstream ss(rawMessage);

    std::string token;


    // Skip the command part

    ss >> token;

    if (!token.empty() && token[0] == ':') { // if there's a prefix

        ss >> token;

    }


    while (ss >> token) {

        if (!token.empty() && token[0] == ':') {

            // This is the last argument, which can contain spaces

            std::string lastArg;

            getline(ss, lastArg, '\n'); // Read the rest of the line

            if (!lastArg.empty() && (lastArg[lastArg.size() - 1] == '\r')) {

                lastArg.erase(lastArg.size() - 1); // remove \r

            }

            args.push_back(token.substr(1) + lastArg);

            break;

        }

        args.push_back(token);

    }

    return args;

}


void CommandManager::parseAndExecute(Client *client, const std::string &rawMessage) {

    if (rawMessage.empty() || !client) {

        return;

    }


    std::string command = getCommand(rawMessage);

    if (command.empty()) {

        return;

    }


    std::map<std::string, ICommand *>::iterator it = _commands.find(command);

    if (it != _commands.end()) {

        std::vector<std::string> args = getArguments(rawMessage);

        it->second->execute(client, args);

        client->updateActivityTime(); // クライアントのアクティビティタイムを更新

        // --- debug ---

        // std::cout << "args: ";

        // for (const std::string &arg : args) {

        //    std::cout << arg << " ";

        //}

        // std::cout << std::endl;

        // std::cout << "first: " << it->first << std::endl;

        // std::cout << client->getNickname() << std::endl;

        // -------------

    } else {

        std::vector<std::string> params;

        params.push_back(command);

        client->sendMessage(

            formatReply(this->_server->getServerName(), client->getNickname(), ERR_UNKNOWNCOMMAND, params));

    }

}


Client.hpp
Manages client connection and state.

CommandManager.hpp
Manages IRC commands and their execution.

InviteCommand.hpp
Handles the INVITE command.

JoinCommand.hpp
Handles the JOIN command.

KickCommand.hpp
Handles the KICK command.

ListCommand.hpp
Handles the LIST command.

ModeCommand.hpp
Handles the MODE command.

NamesCommand.hpp
Handles the NAMES command.

NickCommand.hpp
Handles the NICK command.

NoticeCommand.hpp
Handles the NOTICE command.

PartCommand.hpp
Handles the PART command.

PassCommand.hpp
Handles the PASS command.

PingCommand.hpp
Handles the PING command.

PongCommand.hpp
Handles the PONG command.

PrivmsgCommand.hpp
Handles the PRIVMSG command.

QuitCommand.hpp
Handles the QUIT command.

formatReply
std::string formatReply(const std::string &serverName, const std::string &clientNickname, const std::string &replyCodeAndText)
Formats an IRC reply message without extra parameters.
Definition Replies.cpp:14

Replies.hpp
Defines IRC numeric replies and error messages.

ERR_UNKNOWNCOMMAND
#define ERR_UNKNOWNCOMMAND
Definition Replies.hpp:70

Server.hpp
Core IRC server implementation.

TopicCommand.hpp
Handles the TOPIC command.

UserCommand.hpp
Handles the USER command.

WhoCommand.hpp
Handles the WHO command.

WhoisCommand.hpp
Handles the WHOIS command.

algorithm

std::string

std::stringstream

std::map::begin
T begin(T... args)

Client
Represents an IRC client connected to the server.
Definition Client.hpp:25

Client::updateActivityTime
void updateActivityTime()
Updates the client's last activity time to the current time.
Definition Client.cpp:87

Client::sendMessage
virtual void sendMessage(const std::string &message) const
Sends a message to the client by appending it to the send buffer.
Definition Client.cpp:135

Client::getNickname
const std::string & getNickname() const
Gets the client's nickname.
Definition Client.cpp:25

CommandManager::CommandManager
CommandManager(Server *server)
Constructs a new CommandManager object.
Definition CommandManager.cpp:36

CommandManager::parseAndExecute
void parseAndExecute(Client *client, const std::string &rawMessage)
Parses a raw message and executes the corresponding command.
Definition CommandManager.cpp:117

CommandManager::~CommandManager
~CommandManager()
Destroys the CommandManager object and frees all registered command objects.
Definition CommandManager.cpp:57

InviteCommand
Implements the INVITE command.
Definition InviteCommand.hpp:20

JoinCommand
Implements the JOIN command.
Definition JoinCommand.hpp:21

KickCommand
Implements the KICK command.
Definition KickCommand.hpp:20

ListCommand
Implements the LIST command.
Definition ListCommand.hpp:20

ModeCommand
Implements the MODE command.
Definition ModeCommand.hpp:21

NamesCommand
Implements the NAMES command.
Definition NamesCommand.hpp:21

NickCommand
Implements the NICK command.
Definition NickCommand.hpp:20

NoticeCommand
Implements the NOTICE command.
Definition NoticeCommand.hpp:21

PartCommand
Implements the PART command.
Definition PartCommand.hpp:21

PassCommand
Implements the PASS command.
Definition PassCommand.hpp:20

PingCommand
Implements the PING command.
Definition PingCommand.hpp:23

PongCommand
Implements the PONG command.
Definition PongCommand.hpp:22

PrivmsgCommand
Implements the PRIVMSG command.
Definition PrivmsgCommand.hpp:21

QuitCommand
Implements the QUIT command.
Definition QuitCommand.hpp:20

Server
Implements the core IRC server functionality as a Singleton.
Definition Server.hpp:49

Server::getServerName
const std::string & getServerName() const
Gets the server's name.
Definition Server.cpp:381

TopicCommand
Implements the TOPIC command.
Definition TopicCommand.hpp:20

UserCommand
Implements the USER command.
Definition UserCommand.hpp:20

WhoCommand
Implements the WHO command.
Definition WhoCommand.hpp:20

WhoisCommand
Implements the WHOIS command.
Definition WhoisCommand.hpp:20

std::string::empty
T empty(T... args)

std::map::end
T end(T... args)

std::string::erase
T erase(T... args)

std::string::find
T find(T... args)

std::getline
T getline(T... args)

iostream

std::map

std::vector::push_back
T push_back(T... args)

std::string::size
T size(T... args)

sstream

std::string::substr
T substr(T... args)

std::transform
T transform(T... args)

std::vector