source: source/ariba/utility/addressing/tcpip_endpoint.hpp@ 6841

#ifndef TCPIP_ENDPOINT_HPP_
#define TCPIP_ENDPOINT_HPP_

#include<string>

#include<boost/tr1/functional.hpp>
#include<boost/asio.hpp>

#include "detail/address_convenience.hpp"
#include "port_address.hpp"
#include "ip_address.hpp"

namespace ariba {
namespace addressing {

using boost::asio::ip::tcp;
using namespace std;

struct tcp_address_info {
        static const uint16_t type_id;
        static const std::string type_name;
};

typedef port_address_tpl<tcp_address_info> tcp_port_address;

/**
 * TODO: Doc
 *
 * @author Sebastian Mies <mies@tm.uka.de>
 */
class tcpip_endpoint : public detail::address_convenience<tcpip_endpoint> {
private:
        ip_address ip;
        tcp_port_address port_;
        static const std::string protocol_name;

public:
        typedef tcpip_endpoint self;

public:
        tcpip_endpoint() :
                ip(), port_() {
        }

        tcpip_endpoint( const tcpip_endpoint& copy ) {
                assign(copy);
        }

        tcpip_endpoint( uint16_t port ) : ip(address_v6::any()), port_(port) {
        }

        tcpip_endpoint( const ip_address& ip, const tcp_port_address& port) :
                ip(ip), port_(port) {
        }

        tcpip_endpoint(const  std::string& ip, const std::string& port) :
                ip(ip), port_(port) {
        }

        tcpip_endpoint(const std::string& ip, uint16_t port) :
                ip(ip), port_(port) {
        }

        tcpip_endpoint(const std::string& text) {
                assign( text );
        }

        tcpip_endpoint(const char* text) {
                assign( std::string(text) );
        }

        tcpip_endpoint(const uint8_t* bytes, size_t size) {
                assign( bytes, size );
        }

        bool assign( const self& copy ) {
                this->ip = copy.ip;
                this->port_ = copy.port_;
                return false;
        }

        //--- compare operations --------------------------------------------------

        /// implements comparison operators
        int compare_to(const self& rhs) const {
                if (ip.compare_to(rhs.ip)==0 && port_.compare_to(rhs.port_)==0) return 0;
                return 1;
        }

        //--- bytes representation ------------------------------------------------

        /// returns true, if this address has a fixed size in bytes
        bool is_bytes_size_static() const {
                return false;
        }

        /// returns the number of bytes used for serialization of this address
        size_t to_bytes_size() const {
                return ip.to_bytes_size() + port_.to_bytes_size();
        }

        /// converts this address to a binary representation
        void to_bytes(uint8_t* bytes) const {
                ip.to_bytes(bytes);
                port_.to_bytes(bytes+ip.to_bytes_size());
        }

        /// Assigns an address using a bunch of bytes
        bool assign(const uint8_t* bytes, size_t size) {
                assert(size==6 || size==18);
                if (size==6) {
                        ip.assign(bytes,4);
                        port_.assign(bytes+4,2);
                } else {
                        ip.assign(bytes,16);
                        port_.assign(bytes+16,2);
                }
                return false;
        }

        //--- text representation -------------------------------------------------

        /// convert address to a string that can be used to reconstruct the address
        std::string to_string() const {
                if (ip.asio().is_v4())
                        return ip.to_string()+std::string(":")+port_.to_string();
                else
                        return std::string("[")+ip.to_string()+std::string("]:")+port_.to_string();
        }

        /// Assigns an address using a human-readable
        bool assign(const std::string& text) {
                std::string ip_str;
                std::string port_str;
                if (text.at(0)=='[') {
                        int i = text.find(']',1);
                        ip_str = text.substr(1,i-1);
                        port_str = text.substr(i+2, text.size()-i-1);
                } else {
                        int i = text.find(':',1);
                        ip_str = text.substr(0,i);
                        port_str = text.substr(i+1, text.size()-i-1);
                }
                return ip.assign(ip_str) || port_.assign(port_str);
        }

        //--- address info --------------------------------------------------------

        /// returns the name of the address
        const string& type_name() const {
                return protocol_name;
        }

        /// returns the id of the address
        uint16_t type_id() const {
                return 6;
        }

        //--- endpoint elements ---------------------------------------------------

        ip_address& address() {
                return ip;
        }

        const ip_address& address() const {
                return ip;
        }

        tcp_port_address& port() {
                return port_;
        }

        const tcp_port_address& port() const {
                return port_;
        }

        //--- conversions ---------------------------------------------------------

        /// returns the asio endpoint
        tcp::endpoint asio() const {
                return tcp::endpoint(ip.asio(), port_.asio());
        }

        /// sets the asio endpoint
        void asio( tcp::endpoint& endp ) {
                ip.asio(endp.address());
                port_.asio(endp.port());
        }
};

}} // namespace ariba::addressing

namespace boost {

template<>
struct hash<ariba::addressing::tcpip_endpoint>:
        public std::unary_function<ariba::addressing::tcpip_endpoint, std::size_t> {
        std::size_t operator()(const ariba::addressing::tcpip_endpoint& ep) const {
                return hash_value(ep.to_string());
        }
};

}


#endif /* TCPIP_ENDPOINT_HPP_ */