source: source/ariba/utility/addressing/rfcomm_endpoint.hpp@ 10700

#ifndef RFCOMM_ENDPOINT_HPP_
#define RFCOMM_ENDPOINT_HPP_

#include<string>

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

#include "detail/address_convenience.hpp"

#include "port_address.hpp"
#include "mac_address.hpp"

namespace ariba {
namespace addressing {

using namespace std;

struct rfcomm_channel_address_info {
        static const uint16_t type_id;
        static const std::string type_name;
};
typedef port_address_tpl<rfcomm_channel_address_info> rfcomm_channel_address;

/**
 * TODO: Doc
 *
 * @author Sebastian Mies <mies@tm.uka.de>
 */
class rfcomm_endpoint : public detail::address_convenience<rfcomm_endpoint> {
private:
        mac_address mac_;
        rfcomm_channel_address channel_;
        static const std::string protocol_name;

public:
        typedef rfcomm_endpoint self;

public:
        rfcomm_endpoint() :
                mac_(), channel_() {
        }

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

        rfcomm_endpoint( const mac_address& mac, const rfcomm_channel_address& channel) :
                mac_(mac), channel_(channel) {
        }

        rfcomm_endpoint(const  std::string& mac, const std::string& channel) :
                mac_(mac), channel_(channel) {
        }

        rfcomm_endpoint(const std::string& mac, uint16_t channel) :
                mac_(mac), channel_(channel) {
        }

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

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

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

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

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

        /// implements comparison operators
        int compare_to(const self& rhs) const {
                if (mac_.compare_to(rhs.mac_)==0 && channel_.compare_to(rhs.channel_)==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 true;
        }

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

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

        /// Assigns an address using a bunch of bytes
        bool assign(const uint8_t* bytes, size_t size) {
                assert(size==8);
                return false;
        }

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

        /// convert address to a string that can be used to reconstruct the address
        std::string to_string() const {
                return std::string("[")+mac_.to_string()+std::string("]:")+channel_.to_string();
        }

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

        //--- 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 0xFE05;
        }

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

        mac_address& mac() {
                return mac_;
        }

        const mac_address& mac() const {
                return mac_;
        }

        rfcomm_channel_address& channel() {
                return channel_;
        }

        const rfcomm_channel_address& channel() const {
                return channel_;
        }
};

}} // namespace ariba::addressing

namespace boost {

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

}


#endif /* RFCOMM_ENDPOINT_HPP_ */