warsvrprotocolftpcommands.h

ftpserver very good sample

/** 
*/

#ifndef WAR_SVR_PROTOCOL_FTP_COMMANDS_H
#define WAR_SVR_PROTOCOL_FTP_COMMANDS_H

/* SYSTEM INCLUDES */


/* PROJECT INCLUDES */


/* LOCAL INCLUDES */

#ifndef WAR_SVR_PROTOCOL_FTP_CMD_H
#   include "WarSvrProtocolFtpCmd.h"
#endif

#ifndef WAR_SVR_PROTOCOL_FTP_ENUMS_H
#   include "WarSvrProtocolFtpEnums.h"
#endif

#ifndef WAR_SVR_ENUMS_H
#   include "WarSvrEnums.h"
#endif

/* FORWARD REFERENCES */

class WarSvrProtocolFtp;

#ifdef __cplusplus
extern "C" 
{
#endif
/****************** BEGIN OLD STYLE C spesific ********/


/****************** END OLD STYLE C spesific **********/
#ifdef __cplusplus 
}
#endif

/****************** BEGIN C++ spesific ****************/

#ifdef __cplusplus

class WarCmdAlias
{
public:
    WarCmdAlias(const WarCmdAlias& from)
        : mAlias(from.mAlias),
        mCommand(from.mCommand)
    {
    }

    WarCmdAlias(war_ccstr_t strAlias, 
        war_ccstr_t strCommand)
        : mAlias(strAlias),
        mCommand(strCommand)
    {
    }
    
    bool operator < (const WarCmdAlias& from) const
    {
        return mAlias < from.mAlias;
    }
    
    bool operator == (const WarCmdAlias& from) const
    {
        return mAlias == from.mAlias;
    }

    WarCmdAlias& operator = (const WarCmdAlias& from)
    {
        mAlias = from.mAlias;
        mCommand = from.mCommand;

        return *this;
    }
    
    std::string mAlias;
    std::string mCommand;
public:
};

class WarCmdDefinition
{
public:
    WarCmdDefinition(const std::string& name, 
        bool isImplemented)
        : mName(name),
        mIsImplemented(isImplemented)
    {}

    WarCmdDefinition(const WarCmdDefinition& from)
        : mName(from.mName),
        mIsImplemented(from.mIsImplemented)
    {}

    bool operator < (const WarCmdDefinition& from) const
    {
        return mName < from.mName;
    }

    bool operator == (const WarCmdDefinition& from) const
    {
        return mName == from.mName;
    }

    const std::string& GetName() const
    {
        return mName;
    }

    const bool IsImplemented() const
    {
        return mIsImplemented;
    }

private:
    const std::string mName;
    const bool mIsImplemented;
};

typedef std::set<WarCmdDefinition> war_cmddef_set_t;

class WarSvrProtocolFtpCommands : 
    public WarSvrProtocolFtpEnums,
    public WarSvrEnums
{
public:
    typedef std::set<WarCmdAlias> cmd_alias_t;

    // LIFECYCLE
    
    /**
    * Default constructor.
    */
    WarSvrProtocolFtpCommands(void);
    
    /**
    * Destructor.
    */
    ~WarSvrProtocolFtpCommands(void);
    
    // OPERATORS 
    // OPERATIONS                       
    void InnstallCommand(war_ftpcmd_ptr_t& command,
        bool doReplace = true);

    void InstallAlias(war_ccstr_t strAlias, 
        war_ccstr_t strCommand)
    {
        mCmdAliases.insert(WarCmdAlias(strAlias, strCommand));
    }

    void OnCommand(war_ccstr_t cmdName, 
        war_ccstr_t cmdBuffer, 
        size_t bufferLength);

    void AssignToServer(WarSvrProtocolFtp *pServer)
    {
        mpCompanion = pServer;
    }

    // ACCESS

    WarSvrProtocolFtpCmd *GetCmdPtr(war_ccstr_t cmdName);

    const war_ftpcmd_set_t& GetCommands() const
    {
        return mCommandSet;
    }

    // INQUIRY

    void GetCommandDefs(war_cmddef_set_t& returnVal) const;

    const WarSvrProtocolFtpCmd& GetCurrentCommand() const
    {
        return ReturnCommand(mpCurrentCommand);
    }

    const WarSvrProtocolFtpCmd& GetPreviousCommand() const
    {
        return ReturnCommand(mpPrevCommand);
    }

#if WAR_RFC2389
    const std::string GetFeatures() const;
#endif // WAR_RFC2389


  
protected:
private:
    const WarSvrProtocolFtpCmd& 
        ReturnCommand(WarSvrProtocolFtpCmd *pCommand) const
    {
        if (pCommand == NULL)
            WarThrow(WarError(WAR_ERR_NO_OBJECT), NULL);
        
        return *pCommand;
    }

    war_ftpcmd_set_t mCommandSet;
    WarSvrProtocolFtp *mpCompanion;
    cmd_alias_t mCmdAliases;
    WarSvrProtocolFtpCmd *mpPrevCommand;
    WarSvrProtocolFtpCmd *mpCurrentCommand;
};

/* INLINE METHODS */

/* EXTERNAL REFERENCES */

#endif /* __cplusplus */

/****************** END C++ spesific ******************/

#endif  /* WAR_SVR_PROTOCOL_FTP_COMMANDS_H_ */