cNetAddrName.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cNetAddrName_H
#define _INC_cNetAddrName_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNetAddr.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cNetAddrName);
 
        class GRAYLIB_LINK cNetAddrName
        {
 
        protected:
                cStringA m_sAddrName;                   
                NET_PORT_t m_wPortDefault;      
                cNetAddress m_Addr;                             
 
        protected:
                void FixAddrName();
 
        public:
                cNetAddrName(NET_PORT_t wPortDefault = k_NET_PORT_INVALID)
                : m_wPortDefault(wPortDefault)
                {
                        ASSERT(!m_Addr.isAddrValid());
                }
                cNetAddrName(const char* pszHostAndPort, bool bWait = false)
                : m_sAddrName(pszHostAndPort)
                , m_wPortDefault(k_NET_PORT_INVALID)
                , m_Addr(pszHostAndPort, bWait)
                {
                }
                cNetAddrName(const char* pszHostAndMaybePort, NET_PORT_t wPortDefault, bool bWait = false)
                : m_sAddrName(pszHostAndMaybePort)
                , m_wPortDefault(wPortDefault)
                , m_Addr(pszHostAndMaybePort, wPortDefault, bWait)
                {
                        FixAddrName();
                }
                cNetAddrName(in_addr ip, NET_PORT_t wPort)
                : m_wPortDefault(k_NET_PORT_INVALID)
                , m_Addr(ip, wPort)
                {
                        m_sAddrName = m_Addr.get_AddrStr();     // ="1.2.3.4:port"
                }
 
                static inline bool IsValidHostNameChar(char ch)
                {
                        switch (ch)
                        {
                        case '.':
                        case '-':
                                return true;
                        }
                        if (ch >= 'a'&&ch <= 'z')
                                return true;
                        if (ch >= 'A'&&ch <= 'Z')
                                return true;
                        if (ch >= '0'&&ch <= '9')
                                return true;
                        return false;
                }
 
                HRESULT UpdateHostAddrFromName(bool bWait);
                HRESULT UpdateHostNameFromAddr(bool bWait);
 
                bool isAddrValid() const
                {
                        return m_Addr.isAddrValid();
                }
                const cNetAddress& get_Addr() const
                {
                        return m_Addr;
                }
                cNetAddress& ref_Addr()
                {
                        return m_Addr;
                }
 
                HRESULT SetAddr(const cNetAddress& rAddr, bool bWait = false)
                {
                        m_Addr.put_Addr(rAddr);
                        return UpdateHostNameFromAddr(bWait);   // reset name
                }
 
                NET_PORT_t get_AddrPort() const
                {
                        return m_Addr.get_PortNumber();
                }
                void SetAddrPort(NET_PORT_t wPort, bool bHasNonDefaultPort = false);
 
                bool MakeValidHostAddr()
                {
                        if (isAddrValid())      // m_Addr is valid ?
                        {
                                return true;
                        }
                        // already tried?
                        return(UpdateHostAddrFromName(true) == S_OK);
                }
 
                bool isEmptyAddrName() const
                {
                        return(m_sAddrName.IsEmpty());
                }
                void SetEmptyAddrName()
                {
                        m_sAddrName.Empty();
                        m_Addr.ResetHost();
                }
                cStringA get_AddrName() const
                {
                        return m_sAddrName;     // host name
                }
                HRESULT SetAddrName(cStringA sAddr, bool bWait = false);
 
                cStringA get_HostName() const;
                HRESULT SetHostName(const char* pszHost, bool bWait = false);
                HRESULT SetHostNameLocal(bool bWait);
                void ResetHost()
                {
                        m_Addr.ResetHost();
                }
 
                UNITTEST_FRIEND(cNetAddrName);
        };
}
#endif