Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

IPvXAddress Class Reference

#include <IPvXAddress.h>

List of all members.

Detailed Description

Stores an IPv4 or an IPv6 address. This class should be used everywhere in transport layer and up, to guarantee IPv4/IPv6 transparence.

Storage is efficient: an object occupies size of an IPv6 address (128bits=16 bytes) plus a bool.


Public Member Functions

 IPvXAddress ()
 IPvXAddress (const IPAddress &addr)
 IPvXAddress (const IPv6Address &addr)
 IPvXAddress (const char *addr)
 IPvXAddress (const IPvXAddress &addr)
 ~IPvXAddress ()
bool isIPv6 () const
IPAddress get4 () const
IPv6Address get6 () const
void set (const IPAddress &addr)
void set (const IPv6Address &addr)
void set (const IPvXAddress &addr)
void set (const char *addr)
IPvXAddress & operator= (const IPAddress &addr)
IPvXAddress & operator= (const IPv6Address &addr)
IPvXAddress & operator= (const IPvXAddress &addr)
bool tryParse (const char *addr)
std::string str () const
bool isUnspecified () const
bool equals (const IPAddress &addr) const
bool equals (const IPv6Address &addr) const
bool equals (const IPvXAddress &addr) const
bool operator== (const IPAddress &addr) const
bool operator!= (const IPAddress &addr) const
bool operator== (const IPv6Address &addr) const
bool operator!= (const IPv6Address &addr) const
bool operator== (const IPvXAddress &addr) const
bool operator!= (const IPvXAddress &addr) const
bool operator< (const IPvXAddress &addr) const

Protected Attributes

uint32 d [4]
bool isv6

Constructor & Destructor Documentation

IPvXAddress::IPvXAddress (   )  [inline]
 

Constructor for IPv4 addresses. 

00048 {isv6 = false; d[0] = 0;}

IPvXAddress::IPvXAddress (  const IPAddress &  addr  )  [inline]
 

Constructor for IPv4 addresses. 

00053 {set(addr);}

IPvXAddress::IPvXAddress (  const IPv6Address &  addr  )  [inline]
 

Constructor for IPv6 addresses. 

00058 {set(addr);}

IPvXAddress::IPvXAddress (  const char *  addr  )  [inline]
 

Accepts string representations suuported by IPAddress (dotted decimal notation) and IPv6Address (hex string with colons). Throws an error if the format is not recognized. 

00065 {set(addr);}

IPvXAddress::IPvXAddress (  const IPvXAddress &  addr  )  [inline]
 

Copy constructor. 

00070 {set(addr);}

IPvXAddress::~IPvXAddress (   )  [inline]
 

Destructor 

00075 {}

Member Function Documentation

bool IPvXAddress::equals (  const IPvXAddress &  addr  )  const [inline]
 

Returns true if the two addresses are equal 

00203                                                {
00204         return d[0]==addr.d[0] && (!isv6 || (d[1]==addr.d[1] && d[2]==addr.d[2] && d[3]==addr.d[3]));
00205     }

bool IPvXAddress::equals (  const IPv6Address &  addr  )  const [inline]
 

Returns true if the two addresses are equal 

00195                                                {
00196         uint32 *w = const_cast<IPv6Address&>(addr).words();
00197         return isv6 && d[0]==w[0] && d[1]==w[1] && d[2]==w[2] && d[3]==w[3];
00198     }

bool IPvXAddress::equals (  const IPAddress &  addr  )  const [inline]
 

Returns true if the two addresses are equal 

00188                                              {
00189         return !isv6 && d[0]==addr.getInt();
00190     }

IPAddress IPvXAddress::get4 (   )  const [inline]
 

Get IPv4 address. Throws exception if this is an IPv6 address. 

00088                            {
00089         if (isv6)
00090             throw new cException("IPvXAddress: cannot return IPv6 address %s as IPv4", str().c_str());
00091         return IPAddress(d[0]);
00092     }

IPv6Address IPvXAddress::get6 (   )  const [inline]
 

Get IPv6 address. Throws exception if this is an IPv4 address. 

00097                              {
00098         if (!isv6)  {
00099             if (d[0]==0) // allow null address to be returned as IPv6
00100                 return IPv6Address();
00101             throw new cException("IPvXAddress: cannot return IPv4 address %s as IPv6", str().c_str());
00102         }
00103         return IPv6Address(d[0], d[1], d[2], d[3]);
00104     }

bool IPvXAddress::isIPv6 (   )  const [inline]
 

Is this an IPv6 address? 

00083 {return isv6;}

bool IPvXAddress::isUnspecified (   )  const [inline]
 

True if the structure has not been assigned any address yet. 

00181                                {
00182         return !isv6 && d[0]==0;
00183     }

bool IPvXAddress::operator!= (  const IPvXAddress &  addr  )  const [inline]
 

Returns !equals(addr). 

00235 {return !equals(addr);}

bool IPvXAddress::operator!= (  const IPv6Address &  addr  )  const [inline]
 

Returns !equals(addr). 

00225 {return !equals(addr);}

bool IPvXAddress::operator!= (  const IPAddress &  addr  )  const [inline]
 

Returns !equals(addr). 

00215 {return !equals(addr);}

bool IPvXAddress::operator< (  const IPvXAddress &  addr  )  const [inline]
 

Compares two addresses. 

00240                                                   {
00241         if (isv6!=addr.isv6)
00242             return !isv6;
00243         else if (!isv6)
00244             return d[0]<addr.d[0];
00245         else
00246             return memcmp(&d, &addr.d, 16) < 0;  // this provides an ordering, though not surely the one one would expect
00247     }

IPvXAddress& IPvXAddress::operator= (  const IPvXAddress &  addr  )  [inline]
 

Assignment 

00162 {set(addr); return *this;}

IPvXAddress& IPvXAddress::operator= (  const IPv6Address &  addr  )  [inline]
 

Assignment 

00157 {set(addr); return *this;}

IPvXAddress& IPvXAddress::operator= (  const IPAddress &  addr  )  [inline]
 

Assignment 

00152 {set(addr); return *this;}

bool IPvXAddress::operator== (  const IPvXAddress &  addr  )  const [inline]
 

Returns equals(addr). 

00230 {return equals(addr);}

bool IPvXAddress::operator== (  const IPv6Address &  addr  )  const [inline]
 

Returns equals(addr). 

00220 {return equals(addr);}

bool IPvXAddress::operator== (  const IPAddress &  addr  )  const [inline]
 

Returns equals(addr). 

00210 {return equals(addr);}

void IPvXAddress::set (  const char *  addr  )  [inline]
 

Accepts string representations supported by IPAddress (dotted decimal notation) and IPv6Address (hex string with colons). Throws an error if the format is not recognized. 

00144                                {
00145         if (!tryParse(addr))
00146             throw new cRuntimeError("IPvXAddress: cannot interpret address string `%s'", addr);
00147     }

void IPvXAddress::set (  const IPvXAddress &  addr  )  [inline]
 

Assignment 

00131                                       {
00132         isv6 = addr.isv6;
00133         d[0] = addr.d[0];
00134         if (isv6) {
00135             d[1] = addr.d[1]; d[2] = addr.d[2]; d[3] = addr.d[3];
00136          }
00137     }

void IPvXAddress::set (  const IPv6Address &  addr  )  [inline]
 

Set to an IPv6 address. 

00117                                        {
00118         if (addr.isUnspecified()) {
00119             // we always represent nulls as IPv4 null
00120             isv6 = false; d[0] = 0;
00121             return;
00122         }
00123         isv6 = true;
00124         uint32 *w = const_cast<IPv6Address&>(addr).words();
00125         d[0] = w[0]; d[1] = w[1]; d[2] = w[2]; d[3] = w[3];
00126     }

void IPvXAddress::set (  const IPAddress &  addr  )  [inline]
 

Set to an IPv4 address. 

00109                                      {
00110         isv6 = false;
00111         d[0] = addr.getInt();
00112     }

std::string IPvXAddress::str (   )  const [inline]
 

Returns the string representation of the address (e.g. "152.66.86.92") 

00173 {return isv6 ? get6().str() : get4().str();}

bool IPvXAddress::tryParse (  const char *  addr  ) 
 

Parses and assigns the given address and returns true if the string is recognized by IPAddress or IPv6Address, otherwise just returns false. 

00023 {
00024     // try as IPv4
00025     if (IPAddress::isWellFormed(addr))
00026     {
00027         set(IPAddress(addr));
00028         return true;
00029     }
00030 
00031     // try as IPv6
00032     IPv6Address ipv6;
00033     if (ipv6.tryParse(addr))
00034     {
00035         set(ipv6);
00036         return true;
00037     }
00038 
00039     // no luck
00040     return false;
00041 }

Member Data Documentation

uint32 IPvXAddress::d[4] [protected]
 

bool IPvXAddress::isv6 [protected]
 

The documentation for this class was generated from the following files:
Generated on Sat Apr 1 20:52:22 2006 for INET Framework for OMNeT++/OMNEST by  doxygen 1.4.1