wysockaddrinet4.h

一个不错

/* Copyright is licensed under GNU LGPL.                 by I.J.Wang 2003

  WySockAddrINet4 deals with the IPv4 address (AF_INET)

  Note: Class is not decided to be inherited
  Note: construction not support from WyCSeg directly
 
  [Converted] struct sockaddr/ socklen_t/inet_ntop
                  sockaddr_in
*/

#ifndef WYSOCKADDRINET_H__
#define WYSOCKADDRINET_H__
#define WYSOCKADDRINET_VERSION 31

#include "wyret.h"
#include "wystr.h"
#include "wy_sockaddr.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

// Class for IPv4 address (family=AF_INET)
//
class WySockAddrINet4 : public Wy_SockAddr {
  public:
    typedef struct ::in_addr InAddrType;
    typedef ::in_port_t InPortType;

  private:
    static const ::in_addr_t DefaultIP=INADDR_ANY;  // net format
    static const InPortType DefaultPort=0;          // net format
    static const socklen_t DefaultSockLen=sizeof(::sockaddr_in);
  public:
    class IPAddr {
        InAddrType _addr;

        // [Ret] Ok
        //       Wym_EFAULT str inaccessible
        //       Wym_EADDRNOTAVAIL str not recognizable
        //       Wym_EAFNOSUPPORT  str invalid
        //
        WyRet _init(const char* str);
      public:
        static const char class_name[];
        WY_THROW_REPLY;

        IPAddr() WY__TSPC();
        IPAddr(const IPAddr&) WY__TSPC();
        IPAddr(const InAddrType&) WY__TSPC();
        // note: ip is in host representation
        IPAddr(::in_addr_t ip) WY__TSPC();
        IPAddr(const char* cstr);
        IPAddr(const WyStr& str);
        IPAddr(IPAddr&,Wy::ByMove_t) WY__TSPC();

        bool is_default(void) const WY__TSPC();
        InAddrType c_addr(void) const WY__TSPC()
           { return _addr; };
        WyRet notation(WyStr& str) const;
        void reset(void) WY__TSPC();
        void reset(const IPAddr&) WY__TSPC();
        void reset(const InAddrType&) WY__TSPC();
        void reset(::in_addr_t ip) WY__TSPC();
        WyRet reset(const char* cstr);
        WyRet reset(const WyStr& str);
        void swap(IPAddr& addr) WY__TSPC();

        const IPAddr& operator =(const IPAddr&) WY__TSPC();

        bool operator ==(const IPAddr& rhs) const WY__TSPC();
        bool operator !=(const IPAddr& rhs) const WY__TSPC()
             { return !this->operator==(rhs); };
        bool operator ==(const InAddrType& rhs) const WY__TSPC();
        bool operator !=(const InAddrType& rhs) const WY__TSPC()
             { return !this->operator==(rhs); };
        bool operator ==(::in_addr_t rhs) const WY__TSPC();
        bool operator !=(::in_addr_t rhs) const WY__TSPC()
             { return !this->operator==(rhs); };
        bool operator ==(const WyStr& rhs) const;
        bool operator !=(const WyStr& rhs) const
             { return !this->operator==(rhs); };
        bool operator ==(const char* rhs) const;
        bool operator !=(const char* rhs) const
             { return !this->operator==(rhs); };

        const InAddrType& wy_addr_ref(void) const WY__NOTHROW__
           { return _addr; };
    };

    static const char class_name[];
    inline static int family(void) WY__TSPC()
              { return AF_INET; };
    WY_THROW_REPLY;

    WySockAddrINet4() WY__TSPC();
    WySockAddrINet4(const WySockAddrINet4& src) WY__TSPC();
    WySockAddrINet4(const struct ::sockaddr_in&) WY__TSPC();
    WySockAddrINet4(const IPAddr& ip, InPortType port) WY__TSPC();
    WySockAddrINet4(WySockAddrINet4& src, Wy::ByMove_t) WY__TSPC();

    bool is_default(void) const WY__TSPC();

    IPAddr ip(void) const WY__TSPC();
    InPortType port(void) const WY__TSPC();

    // [Override]
    virtual WyRet notation(WyStr& str) const;

    virtual void reset(void) WY__TSPC();
    virtual void reset(const WySockAddrINet4& src) WY__TSPC();
    virtual void reset(const struct ::sockaddr_in&) WY__TSPC();
    virtual void reset(const IPAddr& ip, InPortType port) WY__TSPC();

    virtual const WySockAddrINet4& operator=(const WySockAddrINet4 &rhs) WY__TSPC();

    virtual WyRet _swap(Wy_SockAddr& iaddr) WY__TSPC();
    virtual WySockAddrINet4* _alloc(WyRet&) const;

    bool operator==(const WySockAddrINet4 &rhs) const WY__TSPC();
    bool operator!=(const WySockAddrINet4 &rhs) const WY__TSPC()
              { return !operator==(rhs); };

  private:
    virtual struct ::sockaddr& c_sockaddr(void) WY__TSPC()
              { return (struct ::sockaddr&)(_saddr); };
    virtual const struct ::sockaddr& c_sockaddr(void) const WY__TSPC()
              { return (struct ::sockaddr&)(_saddr); };

    virtual size_t c_sockaddr_size(void) const WY__TSPC()
              { return sizeof(_saddr); };

    virtual  socklen_t& c_addrlen(void) WY__TSPC()
              { return _slen; };
    virtual const socklen_t& c_addrlen(void) const WY__TSPC()
              { return _slen; };

    // [Internal] Initialize default object
    //
    void _init(void) WY__TSPC();

    // [Internal] Initialize object by copy from src
    //
    void _init(const WySockAddrINet4 &src) WY__TSPC();
    void _init(const struct ::sockaddr_in&) WY__TSPC();

    // [Internal] Initialize object to IPv4 address (family=AF_INET)
    //
    //        port= IPv4 Port number
    //            = 0, no port (ephemeral port with bind())
    //        ip  = IP (numerical) address.
    //            = INADDR_ANY
    //
    void _init(const IPAddr& ip, InPortType port) WY__TSPC();

  private:
    class Wy_Assert_Check;

    struct ::sockaddr_in _saddr;
    socklen_t _slen;
};

inline bool operator ==(const WySockAddrINet4::InAddrType& ip1, const WySockAddrINet4::IPAddr& ip2) WY__TSPC()
{ return ip2==ip1; };
inline bool operator !=(const WySockAddrINet4::InAddrType& ip1, const WySockAddrINet4::IPAddr& ip2) WY__TSPC()
{ return ip2!=ip1; };
inline bool operator ==(::in_addr_t ip1, const WySockAddrINet4::IPAddr& ip2) WY__TSPC()
{ return ip2==ip1; };
inline bool operator !=(::in_addr_t ip1, const WySockAddrINet4::IPAddr& ip2) WY__TSPC()
{ return ip2!=ip1; };
inline bool operator ==(const char* ip1, const WySockAddrINet4::IPAddr& ip2)
{ return ip2==ip1; };
inline bool operator !=(const char* ip1, const WySockAddrINet4::IPAddr& ip2)
{ return ip2!=ip1; };
inline bool operator ==(const WyStr& ip1, const WySockAddrINet4::IPAddr& ip2)
{ return ip2==ip1; };
inline bool operator !=(const WyStr& ip1, const WySockAddrINet4::IPAddr& ip2)
{ return ip2!=ip1; };

namespace Wy {
 WyStr wrd(const WySockAddrINet4::IPAddr& addr);
 WyStr wrd(const WySockAddrINet4& addr);
};

/*
// Wy_Array specilization to support struct in_addr, sockaddr_in
//
#include "wy_array.h"

template<>
struct Wy_Array< ::in_addr > : Wy__ArrayValue< ::in_addr > {
  Wy_Array() : Wy__ArrayValue< ::in_addr >() {};
  Wy_Array(size_t s,const ::in_addr& elem) : Wy__ArrayValue< ::in_addr >(s,elem) {};
  Wy_Array(const Wy_Array& s) : Wy__ArrayValue< ::in_addr >(s) {};
  Wy_Array(Wy_Array& p, Wy::ByMove_t t) : Wy__ArrayValue< ::in_addr >(p,t) {};
};

template<>
struct Wy_Array< ::sockaddr_in > : Wy__ArrayValue< ::sockaddr_in > {
  Wy_Array() : Wy__ArrayValue< ::sockaddr_in >() {};
  Wy_Array(size_t s,const ::sockaddr_in& elem) : Wy__ArrayValue< ::sockaddr_in >(s,elem) {};
  Wy_Array(const Wy_Array& s) : Wy__ArrayValue< ::sockaddr_in >(s) {};
  Wy_Array(Wy_Array& p, Wy::ByMove_t t) : Wy__ArrayValue< ::sockaddr_in >(p,t) {};
};
*/

#endif