An Overlay-based
Virtual Network Substrate
SpoVNet

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

Last change on this file since 8606 was 5284, checked in by mies, 15 years ago

+ added new transport modules and adapted ariba to them
+ exchange endpoint descriptors an link establishment
+ clean up of base communication
+ link establishment with in the presence of multiple endpoints
+ local discovery for ipv6, ipv4 and bluetooth mac addresses

File size: 4.0 KB
Line 
1#ifndef RFCOMM_ENDPOINT_HPP_
2#define RFCOMM_ENDPOINT_HPP_
3
4#include<string>
5
6#include<boost/tr1/functional.hpp>
7#include<boost/asio.hpp>
8
9#include "detail/address_convenience.hpp"
10
11#include "port_address.hpp"
12#include "mac_address.hpp"
13
14namespace ariba {
15namespace addressing {
16
17using namespace std;
18
19struct rfcomm_channel_address_info {
20        static const uint16_t type_id;
21        static const std::string type_name;
22};
23typedef port_address_tpl<rfcomm_channel_address_info> rfcomm_channel_address;
24
25/**
26 * TODO: Doc
27 *
28 * @author Sebastian Mies <mies@tm.uka.de>
29 */
30class rfcomm_endpoint : public detail::address_convenience<rfcomm_endpoint> {
31private:
32        mac_address mac_;
33        rfcomm_channel_address channel_;
34        static const std::string protocol_name;
35
36public:
37        typedef rfcomm_endpoint self;
38
39public:
40        rfcomm_endpoint() :
41                mac_(), channel_() {
42        }
43
44        rfcomm_endpoint( const rfcomm_endpoint& copy ) {
45                assign(copy);
46        }
47
48        rfcomm_endpoint( const mac_address& mac, const rfcomm_channel_address& channel) :
49                mac_(mac), channel_(channel) {
50        }
51
52        rfcomm_endpoint(const  std::string& mac, const std::string& channel) :
53                mac_(mac), channel_(channel) {
54        }
55
56        rfcomm_endpoint(const std::string& mac, uint16_t channel) :
57                mac_(mac), channel_(channel) {
58        }
59
60        rfcomm_endpoint(const std::string& text) {
61                assign( text );
62        }
63
64        rfcomm_endpoint(const char* text) {
65                assign( std::string(text) );
66        }
67
68        rfcomm_endpoint(const uint8_t* bytes, size_t size) {
69                assign( bytes, size );
70        }
71
72        bool assign( const self& copy ) {
73                this->mac_ = copy.mac_;
74                this->channel_ = copy.channel_;
75                return false;
76        }
77
78        //--- compare operations --------------------------------------------------
79
80        /// implements comparison operators
81        int compare_to(const self& rhs) const {
82                if (mac_.compare_to(rhs.mac_)==0 && channel_.compare_to(rhs.channel_)==0) return 0;
83                return 1;
84        }
85
86        //--- bytes representation ------------------------------------------------
87
88        /// returns true, if this address has a fixed size in bytes
89        bool is_bytes_size_static() const {
90                return true;
91        }
92
93        /// returns the number of bytes used for serialization of this address
94        size_t to_bytes_size() const {
95                return mac_.to_bytes_size() + channel_.to_bytes_size();
96        }
97
98        /// converts this address to a binary representation
99        void to_bytes(uint8_t* bytes) const {
100                mac_.to_bytes(bytes);
101                channel_.to_bytes(bytes+mac_.to_bytes_size());
102        }
103
104        /// Assigns an address using a bunch of bytes
105        bool assign(const uint8_t* bytes, size_t size) {
106                assert(size==8);
107                return false;
108        }
109
110        //--- text representation -------------------------------------------------
111
112        /// convert address to a string that can be used to reconstruct the address
113        std::string to_string() const {
114                return std::string("[")+mac_.to_string()+std::string("]:")+channel_.to_string();
115        }
116
117        /// Assigns an address using a human-readable
118        bool assign(const std::string& text) {
119                std::string mac_str;
120                std::string channel_str;
121                if (text.at(0)=='[') {
122                        int i = text.find(']',1);
123                        mac_str = text.substr(1,i-1);
124                        channel_str = text.substr(i+2, text.size()-i-1);
125                        return mac_.assign(mac_str) || channel_.assign(channel_str);
126                }
127                return true;
128        }
129
130        //--- address info --------------------------------------------------------
131
132        /// returns the name of the address
133        const string& type_name() const {
134                return protocol_name;
135        }
136
137        /// returns the id of the address
138        uint16_t type_id() const {
139                return 0xFE05;
140        }
141
142        //--- endpoint elements ---------------------------------------------------
143
144        mac_address& mac() {
145                return mac_;
146        }
147
148        const mac_address& mac() const {
149                return mac_;
150        }
151
152        rfcomm_channel_address& channel() {
153                return channel_;
154        }
155
156        const rfcomm_channel_address& channel() const {
157                return channel_;
158        }
159};
160
161}} // namespace ariba::addressing
162
163namespace boost {
164
165template<>
166struct hash<ariba::addressing::rfcomm_endpoint>: public std::unary_function<ariba::addressing::rfcomm_endpoint, std::size_t> {
167        std::size_t operator()(const ariba::addressing::rfcomm_endpoint& ep) const {
168                return hash_value(ep.to_string());
169        }
170};
171
172}
173
174
175#endif /* RFCOMM_ENDPOINT_HPP_ */
Note: See TracBrowser for help on using the repository browser.