source: source/ariba/DataMessage.h@ 12766

Last change on this file since 12766 was 12060, checked in by hock@…, 11 years ago

Reintegrate branch: 20130111-hock-message_classes

improvements:

  • new message classes (reboost, zero-copy)
  • "fast path" for direct links (skip overlay layer)
  • link-properties accessible from the application
  • SystemQueue can call boost::bind functions
  • protlib compatibility removed (32bit overhead saved in every message)
  • addressing2
  • AddressDiscovery discoveres only addresses on which we're actually listening
  • ariba serialization usage reduced (sill used in OverlayMsg)
  • Node::connect, easier and cleaner interface to start-up ariba from the application
  • ariba configs via JSON, XML, etc (boost::property_tree)
  • keep-alive overhead greatly reduced
  • (relayed) overlay links can actually be closed now
  • lost messages are detected in most cases
  • notification to the application when link is transformed into direct-link
  • overlay routing: send message to second best hop if it would be dropped otherwise
  • SequenceNumbers (only mechanisms, so for: upward compatibility)
  • various small fixes


regressions:

  • bluetooth is not yet working again
  • bootstrap modules deactivated
  • liblog4xx is not working (use cout-logging)

This patch brings great performance and stability improvements at cost of backward compatibility.
Also bluetooth and the bootstrap modules have not been ported to the new interfaces, yet.

File size: 3.4 KB
Line 
1#ifndef DATAMESSAGE_H_
2#define DATAMESSAGE_H_
3
4#define USE_MESSAGE_UTILITY
5
6#include <memory>
7#include <inttypes.h>
8
9// use message utility
10#ifdef USE_MESSAGE_UTILITY
11// #include "ariba/utility/messages.h"
12 #include "ariba/utility/messages/Message.h"
13 namespace ariba {
14 typedef utility::Message Message;
15 }
16#endif
17
18namespace ariba {
19
20// define sequence number type
21typedef uint16_t seqnum_t;
22
23/**
24 * \addtogroup public
25 * @{
26 * This class wraps different representations of a message. In its current
27 * version is allows to specify binary data (as void*) with a size specifying
28 * the number of bytes of data or an message object that can be
29 * serialized if necessary. The main idea is, that simulation environments
30 * do not necessarily need to serialize messages.
31 *
32 * For performance reasons methods of this class are inlined where possible!
33 *
34 * @author Sebastian Mies <mies@tm.uka.de>
35 */
36class DataMessage {
37private:
38 void* data; //< internal buffer pointer
39 size_t size; //< internal buffer pointer size
40public:
41 static const DataMessage UNSPECIFIED; //< default implementation of a data message
42
43 /**
44 * Default constructor for a data message
45 */
46 inline DataMessage() {
47 this->data = NULL;
48 this->size = 0;
49 }
50
51 /**
52 * Constructor for a data message
53 * @param data Data buffer to carry in the message
54 * @param size Size of the buffer pointed to
55 */
56 inline DataMessage( const void* data, const size_t size ) {
57 this->data = const_cast<void*>(data);
58 this->size = size;
59 }
60
61 /**
62 * Copy constructor for a data message
63 * @param message The other message to copy from
64 */
65 inline DataMessage(const DataMessage& message){
66 this->data = message.data;
67 this->size = message.size;
68 }
69
70#ifdef USE_MESSAGE_UTILITY
71 /**
72 * Construct a data message from a normal message
73 * @param message The normal message to store
74 */
75 inline DataMessage( const Message* message ) {
76 this->data = (void*)const_cast<Message*>(message);
77 this->size = ~0;
78 }
79
80 /**
81 * Construct a data message from a normal message
82 * @param message The normal message to store
83 */
84 inline DataMessage( const Message& message ) {
85 this->data = (void*)const_cast<Message*>(&message);
86 this->size = ~0;
87 }
88
89 /**
90 * Get the internal message when constructued through one
91 * @return pointer to the message
92 */
93 inline Message* getMessage() const {
94 if (isData()) {
95 return new Message( Data((uint8_t*)data,size*8) );
96 }
97 return (Message*)data;
98 }
99
100 /**
101 * Conversion function to convert to Message*
102 * @return internal message
103 */
104 inline operator Message* () const {
105 return getMessage();
106 }
107#endif
108
109 /**
110 * Is the data message a normal message?
111 * @return true, if the data message is a normal message
112 */
113 inline bool isMessage() const {
114 return size == ~(size_t)0;
115 }
116
117 /**
118 * Is the data message a data message
119 * @return true, if the data message is not a normal message
120 */
121 inline bool isData() const {
122 return !isMessage();
123 }
124
125 /**
126 * Directly access the internal data pointer
127 * @return internal data pointer
128 */
129 inline void* getData() const {
130 return data;
131 }
132
133 /**
134 * Get the size of the internal buffer
135 * @return internal buffer size
136 */
137 inline size_t getSize() const {
138 return size;
139 }
140
141 /**
142 * Is the data message invalid?
143 * @return true, if data message is invalid
144 */
145 inline bool isUnspecified() const {
146 return data == NULL;
147 }
148
149};
150
151} // namespace ariba
152
153/** @} */
154
155#endif /* DATAMESSAGE_H_ */
Note: See TracBrowser for help on using the repository browser.