cabal_address.h

/*
   cabal_address.h
   Basic address object for cabal

   $Id: cabal_address.h,v 1.5 2004/03/31 16:29:37 jonnymind Exp $
---------------------------------------------
   Begin      :
   Author     : Giancarlo Niccolai

   Last modified because:

*/

#ifndef CABAL_ADDRESS_H
#define CABAL_ADDRESS_H

#include <cabal_os.h>
#include <cassert>

#define CABAL_MAX_ALIASES 5

namespace Cabal {

class Address
{
   SockAddrInet m_address;
   
   char m_ip_string[ CABAL_MAX_IP_SIZE ];
   
   NetAddr m_ip_alias[ CABAL_MAX_ALIASES ];
   
   std::string m_host;

public:
   Address()
   {
      Net::initSockAddr( m_address ); // Sets AF_INET, 0, 0
      m_ip_string[ 0 ] = '\0';
      m_ip_alias[ 0 ] = CABAL_INVALID_ADDR;
   }
   
   Address( const std::string &c_address, const NetPort nPort = 0 )
   {
      set( c_address, nPort );
   }

   Address( const char *c_address, const NetPort nPort = 0 )
   {
      set( c_address, nPort );
   }

   Address( const Address &src )
   {
      copy( src );
   }

   Address( const SockAddrInet &addr )
   {
      set( addr );
   }

   void set( const std::string &str, const NetPort nPort = 0 )
   {
      set( str.c_str() );
   }
   
   void set( const char *str, const NetPort nPort = 0 )
   {
      if ( Net::isAddressString(str) ) {
         strncpy( m_ip_string, str, CABAL_MAX_IP_SIZE );
         m_ip_string[ CABAL_MAX_IP_SIZE - 1 ] = '\0';
         Net::initSockAddr( m_address, str, nPort );
      }
      else {
         Net::initSockAddr( m_address );
         m_host = str;
      }
      m_ip_alias[0] = CABAL_INVALID_ADDR;
   }

   void set( const SockAddrInet &addr ) 
   { 
      m_address = addr;
      m_ip_string[ 0 ] = '\0';
   }
   
   void copy( const Address &addr )
   {
      m_address = addr.m_address;
      memcpy( m_ip_string, addr.m_ip_string, sizeof( m_ip_string ) );
      m_host = addr.m_host;
      memcpy( m_ip_alias, addr.m_ip_alias, sizeof( m_ip_alias) );
   }
   
   Address *clone() 
   {
      return new Address( *this );
   }
   
   const std::string &host() {
      if ( m_host == "" ) {
         m_host = ip();
      }
      return m_host;
   }
   
   void host( const std::string &h ) {
      m_host = h;
      Net::initSockAddr( m_address ); // Sets AF_INET, 0, 0
      m_ip_string[ 0 ] = '\0';
      m_ip_alias[ 0 ] = CABAL_INVALID_ADDR;
   }

   
   const char *ip() {
      if ( m_ip_string[ 0 ] == '\0' ) {
         Net::addrToString( m_address, m_ip_string );
      }
      return m_ip_string;
   }
   
   const SockAddrInet &address() const { return m_address; }
      
   SockAddrInet &varAddress() 
   {
      invalidate();
      return m_address;
   }
   
   void invalidate() { m_ip_string[ 0 ] = '\0'; }
   
   StringList *listOfIps() const;

   inline const NetAddr *aliasIpList() const { return m_ip_alias; }
   inline int port() const { return Net::SockAddrGetPort( m_address ); }
   inline void port( const int nPort ) { Net::SockAddrSetPort( m_address, nPort ); }
   
   bool isReady() const { return ! Net::SockAddrIsZero( m_address ); }

   bool Address::scan()
   {
      // prepares the host from the SockAddrIn, if not given, and prevents misuse.
      assert ( host() != "" );
      return Net::getHostList( m_host, m_host, m_ip_string, m_ip_alias, CABAL_MAX_ALIASES );
   }
   
   bool Address::scan( const std::string &host ) {
      m_host = host;
      return scan();
   }
   
   inline void operator=( const Address &orig ) { copy(orig); }
   
   
   inline bool operator==( const Address &a2 ) const
   {  
      return Net::SockAddrIsSame( m_address, a2.m_address );
   }
   
   inline bool operator!=( const Address &a2 ) const 
   {
      return !Net::SockAddrIsSame( m_address, a2.m_address );
   }

};

}

#endif

/* end of cabal_address.h */

---