MunResolverConfigure.hpp

Go to the documentation of this file.

#ifndef __MUN_RESOLVER_CONFIGURE_HPP__
#define __MUN_RESOLVER_CONFIGURE_HPP__

#include    <mrs.hpp>

enum MunServerListen
{
    MUN_SERVER_LISTEN_USE_NONE = 0x00,          
    MUN_SERVER_LISTEN_USE_TCP  = 0x01 << 0,     
    MUN_SERVER_LISTEN_USE_UDP  = 0x01 << 1,     
    MUN_SERVER_LISTEN_USE_WS   = 0x01 << 2,     
    MUN_SERVER_LISTEN_USE_WSS  = 0x01 << 3,     
};

class MunResolverConfigure : public mrs::OptArg
{
protected:
    std::string         m_ProxyServerListeningAddress;
    
    int32               m_ProxyServerListeningPort;
    
    int32               m_ProxyServerListeningBacklog;
    
    int32               m_ClientListeningFlag;
    
    std::string         m_ClientListeningAddress;
    
    int32               m_ClientListeningPortTCP;
    
    int32               m_ClientListeningPortUDP;
    
    int32               m_ClientListeningPortWS;
    
    int32               m_ClientListeningPortWSS;
    
    int32               m_ClientListeningBacklogTCP;
    
    int32               m_ClientListeningBacklogUDP;
    
    int32               m_ClientListeningBacklogWS;
    
    int32               m_ClientListeningBacklogWSS;
    
    int32               m_LogLevel;
    
    bool                m_IsOutputLogFile;
    
    std::string         m_LogDirPath;
    
    int32               m_LogRotate;
    
    uint32              m_KeepAliveUpdateInterval;
    
    std::string         m_MonitoringAddr;
    
    uint16              m_MonitoringPort;
    
public:
    std::string GetProxyServerListeningAddress() { return m_ProxyServerListeningAddress; }
    
    int32   GetProxyServerListeningPort() { return m_ProxyServerListeningPort; }
    
    int32   GetProxyServerListeningBacklog() { return m_ProxyServerListeningBacklog; }
    
    int32    GetClientListeningFlag() { return m_ClientListeningFlag; }
    
    std::string GetClientListeningAddress() { return m_ClientListeningAddress; }
    
    int32   GetClientListeningPortTCP(){ return m_ClientListeningPortTCP; }
    
    int32   GetClientListeningPortUDP(){ return m_ClientListeningPortUDP; }
    
    int32   GetClientListeningPortWS(){ return m_ClientListeningPortWS; }
    
    int32   GetClientListeningPortWSS(){ return m_ClientListeningPortWSS; }
    
    int32   GetClientListeningBacklogTCP(){ return m_ClientListeningBacklogTCP; }
    
    int32   GetClientListeningBacklogUDP(){ return m_ClientListeningBacklogUDP; }
    
    int32   GetClientListeningBacklogWS(){ return m_ClientListeningBacklogWS; }
    
    int32   GetClientListeningBacklogWSS(){ return m_ClientListeningBacklogWSS; }
    
    void    SetLogLevel( int32 level ) { m_LogLevel = level; }
    
    int32   GetLogLevel() { return m_LogLevel; }
    
    bool   GetIsOutputLogFile() { return m_IsOutputLogFile; }
    
    std::string   GetLogDirPath() { return m_LogDirPath; }
    
    int32 GetLogRotate(){ return m_LogRotate; }
    
    uint32 GetKeepAliveUpdateInterval(){ return m_KeepAliveUpdateInterval; }
    
    std::string GetMonitoringAddr(){ return m_MonitoringAddr; }
    
    uint16 GetMonitoringPort(){ return m_MonitoringPort; }
    
public:
    MunResolverConfigure();
    
    virtual ~MunResolverConfigure();
    
    virtual bool Parse( int32 argc, char** argv, mrs::OptArg::Callback callback = NULL );
    
protected:
    virtual bool OnParse( int32 argi, const char* value, char short_name, const char* long_name, const char* default_value, const char* msg );
    
    virtual void PrintUsage();
};

#endif  /* __MUN_RESOLVER_CONFIGURE_HPP__ */