ALDCommand.h

См. документацию.

 
#ifndef ALD_COMMAND
#define ALD_COMMAND
 
#include "common.h"
#include "ALDCore.h"
#include <map>
#include <list>
#include <memory>
 
using namespace std;
 
namespace ALD
{
 
enum acArgumentNecessity {
    anNoArgument = 0,       
    anRequiredArgument = 1, 
    anOptionalArgument = 2  
};
 
enum acArgumentType {
    acatText,       
    acatNumber,     
    acatHex,        
    acatOct,        
    acatTPeriod     
};
 
class CALDCommandOption
{
protected:
    bool m_bActive;                       
    bool m_bMultiple;                     
    bool m_bMandatory;                    
    string m_strName;                     
    int m_iShortIdent;                    
    acArgumentNecessity m_HasArgument;    
    acArgumentType  m_ArgumentType;       
    ald_string_list m_lstArguments;       
public:
    inline const string &name() const {return m_strName;}
    inline int ident() const {return m_iShortIdent;}
    inline bool IsActive() const {return m_bActive;}
    inline bool multiple() const {return m_bMultiple;}
    inline bool mandatory() const {return m_bMandatory;}
    inline acArgumentNecessity hasArgument() const {return m_HasArgument;}
    inline acArgumentType argumentType() const {return m_ArgumentType;}
    void SetActive();
    void SetActive(const string& arg);
    string argument() const;
    unsigned int uargument() const;
    inline ald_string_list& Arguments() {return m_lstArguments;}
    virtual void Clear();
    CALDCommandOption(const string& strName, int iShortIdent = 0,
                      acArgumentNecessity HasArgument = anNoArgument,
                      acArgumentType ArgumentType = acatText,
                      bool bMultiple = false, bool bMandatory = false);
    virtual ~CALDCommandOption();
};
 
typedef shared_ptr<CALDCommandOption> CALDCommandOptionPtr;
 
typedef map<string, CALDCommandOptionPtr> ald_command_option_map;
 
class CALDCommandOptions
{
protected:
    ald_command_option_map m_mapOptions;    
    ald_command_option_map::iterator m_itOption;    
public:
    CALDCommandOptions();
    void begin();
    CALDCommandOptionPtr next();
    CALDCommandOptionPtr OptionByName(const string& strName);
    bool IsActive(const string& opt);
    void Add(CALDCommandOptionPtr Option);
    void Add(CALDCommandOption* pOption);
    void Remove(const string& strName);
    void Assign(const CALDCommandOptions& Options);
    void CopyFrom(CALDCommandOptions& Options);
    void Clear();
    void ClearOptionsState();
    inline size_t Size() const {return m_mapOptions.size();}
    virtual ~CALDCommandOptions();
};
 
class CALDCommand
{
protected:
    string m_strSection;                
    string m_strName;                   
    string m_strDesc;                   
    CALDCommandOptions m_Options;       
    ald_string_list m_lstArguments;     
    acArgumentNecessity m_HasArgument;  
    IALDCore* m_pCore;                  
    bool m_bPrivileged;                 
    bool m_bIndependent;                
 
    bool CheckArguments();              
 
    virtual int Execute() = 0;          
public:
    inline const string &section() const {return m_strSection;}
    inline const string &name() const {return m_strName;}
    inline const string &desc() const {return m_strDesc;}
    string argument() const;
    inline acArgumentNecessity hasArgument() const {return m_HasArgument;}
    inline bool IsPrivileged() const {return m_bPrivileged;}
    inline bool IsIndependent() const {return m_bIndependent;}
    virtual void ShowUsage() const = 0;
    virtual int Run();
    inline CALDCommandOptions& Options() {return m_Options;}
    inline bool OptionIsActive(const string& opt) { return m_Options.IsActive(opt);}
    inline CALDCommandOptionPtr OptionByName(const string& strName) {return m_Options.OptionByName(strName);}
    void AddArgument(const string& arg);
    virtual void Clear();
    virtual void FillRLArguments(const string& option, ald_string_list& list, bool& isfile);
    virtual void FillRLOptions(ald_string_list& list);
    CALDCommand(IALDCore& Core);
    virtual ~CALDCommand();
};
 
typedef shared_ptr<CALDCommand> CALDCommandPtr;
typedef map<string, CALDCommandPtr> ald_command_map;
 
class CALDCommands
{
protected:
    ald_command_map m_mapCommands;  
    ald_command_map::iterator m_itCommand; 
public:
    CALDCommands();
    void begin();
    CALDCommandPtr next();
    CALDCommandPtr CommandByName(const string& strName);
    void Remove(const string& strName);
    void RemoveCommands(CALDCommands& Commands);
    void Add(CALDCommandPtr Command);
    void Add(CALDCommand* pCommand);
    void Add(CALDCommands& Commands);
    void Assign(const CALDCommands& Commands);
    void Clear();
    size_t Size() const;
    virtual ~CALDCommands();
};
 
 
} // ALD
 
#endif // ALD_COMMAND