Leviathan::CommandHandler Class Reference

Handles all commands sent by the players on the server. More...

#include <CommandHandler.h>

Public Member Functions
DLLEXPORT	CommandHandler (NetworkServerInterface *owneraccess)
	Constructs a CommandHandler for use by a single server network interface. More...
virtual DLLEXPORT	~CommandHandler ()
virtual DLLEXPORT void	QueueCommand (const std::string &command, CommandSender *issuer)
	Queues a command to be executed. More...
virtual DLLEXPORT void	UpdateStatus ()
	Call this periodically to perform cleanup tasks. More...
virtual DLLEXPORT void	RemoveMe (CommandSender *object)
	This should be called by CommandSender subclasses when they are no longer available to remove their commands from the queue. More...
virtual DLLEXPORT bool	IsSenderStillValid (CommandSender *checkthis)
	Called by an actual command callback to make sure that the sender is still active. More...
virtual DLLEXPORT void	SenderNoLongerRequired (CommandSender *checkthis)
	Called by a command handler when a CommandSender is no longer needed. More...
virtual DLLEXPORT bool	RegisterCustomCommandHandler (std::shared_ptr< CustomCommandHandler > handler)
	Registers a new custom command handler. More...
virtual DLLEXPORT bool	IsThisDefaultCommand (const std::string &firstword) const
	Returns true when the default command handling function can process this. More...

Static Public Member Functions
static DLLEXPORT CommandHandler *	Get ()

Protected Member Functions
void	_LetGoOfAll ()
	Lets go of all the CommandSenders. More...
void	_AddSender (CommandSender *object)
	Adds a CommandSender to the list of active ones. More...

Protected Attributes
std::list< CommandSender * >	SendersInUse
	Holds all the command dispatchers who are currently executing commands. More...
NetworkServerInterface *	Owner
	Pointer to the owning interface for fetching various other things. More...
std::vector< std::shared_ptr< CustomCommandHandler > >	CustomHandlers
	All the custom command providers. More...

Static Protected Attributes
static CommandHandler *	Staticaccess
	A static access member for command executing functions. More...

Detailed Description

Handles all commands sent by the players on the server.

Definition at line 77 of file CommandHandler.h.

Constructor & Destructor Documentation

CommandHandler()

DLLEXPORT Leviathan::CommandHandler::CommandHandler

(

NetworkServerInterface *

owneraccess

)

Constructs a CommandHandler for use by a single server network interface.

Definition at line 39 of file CommandHandler.cpp.

                                                                                     :
    Owner(owneraccess)
{
    Staticaccess = this;
}

~CommandHandler()

DLLEXPORT Leviathan::CommandHandler::~CommandHandler ( )

virtual

Definition at line 45 of file CommandHandler.cpp.

                                                  {
    
    Staticaccess = NULL;

    CustomHandlers.clear();

    // All the pointers have to be removed before deleting this //
    _LetGoOfAll();
}

Member Function Documentation

_AddSender()

void Leviathan::CommandHandler::_AddSender ( CommandSender *  object )

protected

Adds a CommandSender to the list of active ones.

Definition at line 178 of file CommandHandler.cpp.

                                                             {

    // Notify the object //
    object->StartOwnership(this);

    // Add to the list //
    SendersInUse.push_back(object);
}

_LetGoOfAll()

void Leviathan::CommandHandler::_LetGoOfAll ( )

protected

Lets go of all the CommandSenders.

Definition at line 149 of file CommandHandler.cpp.

                                         {

    auto end = SendersInUse.end();
    for(auto iter = SendersInUse.begin(); iter != end; ++iter){

        (*iter)->EndOwnership(this);
    }

    // Clear them all at once //
    SendersInUse.clear();
}

Get()

DLLEXPORT CommandHandler * Leviathan::CommandHandler::Get ( )

static

Definition at line 57 of file CommandHandler.cpp.

                                                      {
    
    return Staticaccess;
}

IsSenderStillValid()

DLLEXPORT bool Leviathan::CommandHandler::IsSenderStillValid ( CommandSender *  checkthis )

virtual

Called by an actual command callback to make sure that the sender is still active.

Parameters

retlock

Will contain a lock for the object so hold onto it while using the object

Definition at line 128 of file CommandHandler.cpp.

                                                                                  {
    
    // Check is it still in the list //
    auto end = SendersInUse.end();
    for(auto iter = SendersInUse.begin(); iter != end; ++iter){
        if(*iter == checkthis){
            // It is still there //
            return true;
        }
    }

    // Not found //
    return false;
}

IsThisDefaultCommand()

DLLEXPORT bool Leviathan::CommandHandler::IsThisDefaultCommand ( const std::string &  firstword ) const

virtual

Returns true when the default command handling function can process this.

Definition at line 198 of file CommandHandler.cpp.

{
    // Didn't match any of the strings, cannot be //
    return false;
}

QueueCommand()

DLLEXPORT void Leviathan::CommandHandler::QueueCommand ( const std::string &  command, CommandSender *  issuer  )

virtual

Queues a command to be executed.

Definition at line 62 of file CommandHandler.cpp.

{
    // Get the first word //
    StringIterator itr(std::make_unique<UTF8DataIterator>(command));

    // Only skip a single / if there is one //
    if(itr.GetCharacter() == '/')
        itr.MoveToNext();

    // Get the first word //
    auto firstword = itr.GetNextCharacterSequence<std::string>(
        UNNORMALCHARACTER_TYPE_LOWCODES);

    if(!firstword || firstword->empty())
        return;



    // Find a command handler that provides handling for this command //

    // First check the default commands //
    if(IsThisDefaultCommand(*firstword)){

        // Queue a default command execution //
        DEBUG_BREAK;

        // Default will also need this //
        _AddSender(issuer);
        return;
    }

    // Loop through and check the custom command handlers //
    auto end = CustomHandlers.end();
    for(auto iter = CustomHandlers.begin(); iter != end; ++iter){

        if((*iter)->CanHandleCommand(*firstword)){
            // Queue the command handler //
            ThreadingManager::Get()->QueueTask(new QueuedTask(std::bind(&RunCustomHandler,
                        *iter, std::make_shared<std::string>(command), issuer)));


            // And take good care of the object while the command handler is waiting //
            _AddSender(issuer);
            return;
        }
    }

    // Couldn't find a handler for command //
    issuer->SendPrivateMessage("Unknown command \""+*firstword+"\"");
}

RegisterCustomCommandHandler()

DLLEXPORT bool Leviathan::CommandHandler::RegisterCustomCommandHandler ( std::shared_ptr< CustomCommandHandler >  handler )

virtual

Registers a new custom command handler.

Parameters

handler

The object to use for handling. The object will be owned by this and will be deleted when it is no longer used

See also

CustomCommandHandler

Definition at line 187 of file CommandHandler.cpp.

{
    // Might be unnecessary to check this, but it's a way to return false sometimes //
    if(!handler)
        return false;

    CustomHandlers.push_back(handler);
    return true;
}

RemoveMe()

DLLEXPORT void Leviathan::CommandHandler::RemoveMe ( CommandSender *  object )

virtual

This should be called by CommandSender subclasses when they are no longer available to remove their commands from the queue.

Definition at line 114 of file CommandHandler.cpp.

                                                                     {

    // Remove from the vector //
    auto end = SendersInUse.end();
    for(auto iter = SendersInUse.begin(); iter != end; ++iter){

        if(*iter == object){
            // Remove the match //
            SendersInUse.erase(iter);
            return;
        }
    }
}

SenderNoLongerRequired()

DLLEXPORT void Leviathan::CommandHandler::SenderNoLongerRequired ( CommandSender *  checkthis )

virtual

Called by a command handler when a CommandSender is no longer needed.

Parameters

stillgotthis

Is the lock received from IsSenderStillValid

Definition at line 161 of file CommandHandler.cpp.

                                                                                      {

    // Remove from the vector //
    auto end = SendersInUse.end();
    for(auto iter = SendersInUse.begin(); iter != end; ++iter){

        if(*iter == checkthis){
            // Notify it //
            (*iter)->EndOwnership(this);

            // Remove the match //
            SendersInUse.erase(iter);
            return;
        }
    }
}

UpdateStatus()

DLLEXPORT void Leviathan::CommandHandler::UpdateStatus ( )

virtual

Call this periodically to perform cleanup tasks.

and depending on actual implementation the command handling. The default implementation doesn't really need this, but it should still be called

Definition at line 144 of file CommandHandler.cpp.

                                                    {


}

Member Data Documentation

CustomHandlers

std::vector<std::shared_ptr<CustomCommandHandler> > Leviathan::CommandHandler::CustomHandlers

protected

All the custom command providers.

Definition at line 149 of file CommandHandler.h.

Owner

NetworkServerInterface* Leviathan::CommandHandler::Owner

protected

Pointer to the owning interface for fetching various other things.

Definition at line 145 of file CommandHandler.h.

SendersInUse

std::list<CommandSender*> Leviathan::CommandHandler::SendersInUse

protected

Holds all the command dispatchers who are currently executing commands.

Definition at line 141 of file CommandHandler.h.

Staticaccess

CommandHandler * Leviathan::CommandHandler::Staticaccess

staticprotected

A static access member for command executing functions.

Definition at line 153 of file CommandHandler.h.

---

The documentation for this class was generated from the following files:

• CommandHandler.h
• CommandHandler.cpp