source: orxonox.OLD/branches/proxy/src/lib/network/ip.cc @ 9308

/**
 * @file ip.cc
 * @brief A IP class, that handles all about time.
 *
 * code taken from audiere.
 */

#include "ip.h"
#include "multi_type.h"
#include "substring.h"

/**
 * @brief default constructor
 */
IP::IP()
{
  this->_ip = 0;
  this->_port = 0;
}


/**
 * @brief constructor from ip and port
 * @param ip the IP
 * @param port the Port
 * @return self
 */
IP::IP(int ip, int port)
{
  this->_ip = ip;
  this->_port = port;
}



/**
 * @brief constructor from a String
 * @param ip the IP as a String.
 * @return self
 */
IP::IP(const std::string& ip)
{
  *this = IP::stringToIP(ip);
}


/**
 * @brief constructor from an SDL net structure IPaddress
 * @param ip the ip.
 * @return self
 */
IP::IP(const IPaddress& ip)
{
  this->_ip = ip.host;
  this->_port = ip.port;
}


/**
 * @brief copy constructor.
 * @param ip the IP to copy.
 * @return self
 */
IP::IP(const IP& ip)
{
  this->_ip = ip.ip();
  this->_port = ip.port();
}



/**
 * @brief copy operator
 * @param ip the IP to copy.
 * @return self.
 */
const IP& IP::operator=(const IP& ip)
{
  this->_ip = ip.ip();
  this->_port = ip.port();
  return *this;
}



/**
 * @brief comparison operator
 * @param ip the IP to compare
 * @return true if ip _and_ port match.
 */
bool IP::operator==(const IP& ip)
{
  return (this->_ip == ip.ip() && this->_port == ip.port());
}


/**
 * @brief converts a String into an IP Object.
 * @param ip The string holding an IP.
 * @return a constructed IP.
 */
IP IP::stringToIP(const std::string& ip)
{
  IPaddress ipaddr;

  SDLNet_ResolveHost(&ipaddr, NULL, 2000);

  return IP(ipaddr);

  /*
  SubString addr(ip, '.');
  if(ip.size() != 4 )
    return -1;

  MultiType part0(ip[0]);
  MultiType part1(ip[1]);
  MultiType part2(ip[2]);
  MultiType part3(ip[3]);
  */
}


/**
 * @brief if you want to have a specific part of an IP
 * @param part the n'th part of the IP addr (splitted by '.').
 * @return the amount held in the designated part.
 */
int IP::ipPart(unsigned int part) const
{
  switch (part)
  {
    case 0:
      return  (_ip & 0xFF000000) >> 24;
    case 1:
      return  (_ip & 0x00FF0000) >> 16;
    case 2:
      return  (_ip & 0x0000FF00) >> 8;
    case 3:
      return  (_ip & 0x000000FF);
    default:
      return -1;
  }

}


/**
 * @return the Ip as a string.
 */
std::string IP::ipString() const
{
  return IP::ipToString(this->_ip);
}


/**
 * @brief converts an IPaddress struct into a String.
 * @param ipaddr the IP address as a SDL_net struct.
 * @return the string retrieved from the IP.
 */
std::string IP::ipToString(const IPaddress& ipaddr)
{
  int ip = SDLNet_Read32 (ipaddr.host);
  return ipToString(ip, ipaddr.port);
}





/**
 * converts a IP into a String (without port).
 * @param ip the IP to put into the string.
 * @param port -1 if not wanted
 * @return the string of the ip.
 */
std::string IP::ipToString(int ip, int port)
{
  MultiType part0((int) (ip & 0xFF000000) >> 24);
  MultiType part1((int) (ip & 0x00FF0000) >> 16);
  MultiType part2((int) (ip & 0x0000FF00) >>  8);
  MultiType part3((int) (ip & 0x000000FF) );

  std::string addr = part0.getString() + "." + part1.getString() + "." +
                     part2.getString() + "." + part3.getString();

  if (port != -1)
    addr += MultiType(port).getString();
  return addr;
}