message.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <interface/message.h>
00025 #include <interface/interface.h>
00026
00027 #include <core/threading/thread.h>
00028 #include <core/threading/mutex.h>
00029 #include <core/exceptions/software.h>
00030 #include <utils/time/time.h>
00031
00032 #include <cstring>
00033 #include <cstdlib>
00034 #include <unistd.h>
00035
00036 namespace fawkes {
00037 #if 0
00038 }
00039 #endif
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067 Message::Message(const char *type)
00068 {
00069 __fieldinfo_list = NULL;
00070
00071 __message_id = 0;
00072 __hops = 0;
00073 __enqueued = false;
00074 __num_fields = 0;
00075 data_ptr = NULL;
00076 data_ts = NULL;
00077 _sender_id = 0;
00078 _type = strdup(type);
00079 __time_enqueued = new Time();
00080
00081 _transmit_via_iface = NULL;
00082 sender_interface_instance_serial = 0;
00083 recipient_interface_mem_serial = 0;
00084
00085 Thread *t = Thread::current_thread_noexc();
00086 if ( t ) {
00087 _sender_thread_name = strdup(t->name());
00088 } else {
00089 _sender_thread_name = strdup("Unknown");
00090 }
00091 }
00092
00093
00094
00095
00096
00097 Message::Message(const Message &mesg)
00098 {
00099 __message_id = 0;
00100 __hops = mesg.__hops;
00101 __enqueued = false;
00102 __num_fields = mesg.__num_fields;
00103 data_size = mesg.data_size;
00104 data_ptr = malloc(data_size);
00105 data_ts = (message_data_ts_t *)data_ptr;
00106 _sender_id = 0;
00107 _type = strdup(mesg._type);
00108 __time_enqueued = new Time(mesg.__time_enqueued);
00109
00110 _transmit_via_iface = NULL;
00111 sender_interface_instance_serial = 0;
00112 recipient_interface_mem_serial = 0;
00113
00114 memcpy(data_ptr, mesg.data_ptr, data_size);
00115
00116 interface_fieldinfo_t *info_src = mesg.__fieldinfo_list;
00117 interface_fieldinfo_t **info_dest = &__fieldinfo_list;
00118 while ( info_src ) {
00119 interface_fieldinfo_t *new_info = (interface_fieldinfo_t *)malloc(sizeof(interface_fieldinfo_t));
00120 memcpy(new_info, info_src, sizeof(interface_fieldinfo_t));
00121 *info_dest = new_info;
00122
00123 info_dest = &((*info_dest)->next);
00124 info_src = info_src->next;
00125 }
00126
00127 Thread *t = Thread::current_thread_noexc();
00128 if ( t ) {
00129 _sender_thread_name = strdup(t->name());
00130 } else {
00131 _sender_thread_name = strdup("Unknown");
00132 }
00133 }
00134
00135
00136
00137
00138
00139 Message::Message(const Message *mesg)
00140 {
00141 __message_id = 0;
00142 __hops = mesg->__hops;
00143 __enqueued = false;
00144 __num_fields = mesg->__num_fields;
00145 data_size = mesg->data_size;
00146 data_ptr = malloc(data_size);
00147 data_ts = (message_data_ts_t *)data_ptr;
00148 _sender_id = 0;
00149 _type = strdup(mesg->_type);
00150 _transmit_via_iface = NULL;
00151 sender_interface_instance_serial = 0;
00152 recipient_interface_mem_serial = 0;
00153 __time_enqueued = new Time(mesg->__time_enqueued);
00154
00155 memcpy(data_ptr, mesg->data_ptr, data_size);
00156
00157 interface_fieldinfo_t *info_src = mesg->__fieldinfo_list;
00158 interface_fieldinfo_t **info_dest = &__fieldinfo_list;
00159 while ( info_src ) {
00160 interface_fieldinfo_t *new_info = (interface_fieldinfo_t *)malloc(sizeof(interface_fieldinfo_t));
00161 memcpy(new_info, info_src, sizeof(interface_fieldinfo_t));
00162 *info_dest = new_info;
00163
00164 info_dest = &((*info_dest)->next);
00165 info_src = info_src->next;
00166 }
00167
00168 Thread *t = Thread::current_thread_noexc();
00169 if ( t ) {
00170 _sender_thread_name = strdup(t->name());
00171 } else {
00172 _sender_thread_name = strdup("Unknown");
00173 }
00174 }
00175
00176
00177
00178 Message::~Message()
00179 {
00180 free(_sender_thread_name);
00181 free(_type);
00182 delete __time_enqueued;
00183
00184 interface_fieldinfo_t *infol = __fieldinfo_list;
00185 while ( infol ) {
00186 __fieldinfo_list = __fieldinfo_list->next;
00187 free(infol);
00188 infol = __fieldinfo_list;
00189 }
00190 }
00191
00192
00193
00194
00195
00196 unsigned int
00197 Message::id() const
00198 {
00199 return __message_id;
00200 }
00201
00202
00203
00204
00205
00206 unsigned int
00207 Message::hops() const
00208 {
00209 return __hops;
00210 }
00211
00212
00213
00214
00215
00216 void
00217 Message::set_id(unsigned int message_id)
00218 {
00219 __message_id = message_id;
00220 }
00221
00222
00223
00224
00225
00226 void
00227 Message::set_hops(unsigned int hops)
00228 {
00229 __hops=hops;
00230 }
00231
00232
00233
00234 void
00235 Message::mark_enqueued()
00236 {
00237 __time_enqueued->stamp();
00238 long sec = 0, usec = 0;
00239 __time_enqueued->get_timestamp(sec, usec);
00240 data_ts->timestamp_sec = sec;
00241 data_ts->timestamp_usec = usec;
00242
00243 __enqueued = true;
00244 }
00245
00246
00247
00248
00249
00250 bool
00251 Message::enqueued() const
00252 {
00253 return __enqueued;
00254 }
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264 const Time *
00265 Message::time_enqueued() const
00266 {
00267 return __time_enqueued;
00268 }
00269
00270
00271
00272
00273
00274 unsigned int
00275 Message::recipient() const
00276 {
00277 return recipient_interface_mem_serial;
00278 }
00279
00280
00281
00282
00283
00284 const void *
00285 Message::datachunk() const
00286 {
00287 return data_ptr;
00288 }
00289
00290
00291
00292
00293
00294 unsigned int
00295 Message::datasize() const
00296 {
00297 return data_size;
00298 }
00299
00300
00301
00302
00303
00304
00305
00306 void
00307 Message::set_from_chunk(const void *chunk)
00308 {
00309 memcpy(data_ptr, chunk, data_size);
00310 __time_enqueued->set_time(data_ts->timestamp_sec, data_ts->timestamp_usec);
00311 }
00312
00313
00314
00315
00316
00317
00318
00319 Message &
00320 Message::operator= (const Message & m)
00321 {
00322 if ( data_size == m.data_size ) {
00323 memcpy(data_ptr, m.data_ptr, data_size);
00324 __time_enqueued->set_time(data_ts->timestamp_sec, data_ts->timestamp_usec);
00325 }
00326
00327 return *this;
00328 }
00329
00330
00331
00332
00333
00334 const char *
00335 Message::sender_thread_name() const
00336 {
00337 return _sender_thread_name;
00338 }
00339
00340
00341
00342
00343
00344 unsigned int
00345 Message::sender_id() const
00346 {
00347 return _sender_id;
00348 }
00349
00350
00351
00352
00353
00354
00355 void
00356 Message::set_interface(Interface *iface)
00357 {
00358 _transmit_via_iface = iface;
00359 _sender_id = iface->serial();
00360 recipient_interface_mem_serial = iface->mem_serial();
00361 }
00362
00363
00364
00365
00366
00367 Interface *
00368 Message::interface() const
00369 {
00370 return _transmit_via_iface;
00371 }
00372
00373
00374
00375
00376
00377 const char *
00378 Message::type() const
00379 {
00380 return _type;
00381 }
00382
00383
00384
00385
00386
00387 InterfaceFieldIterator
00388 Message::fields()
00389 {
00390 return InterfaceFieldIterator(_transmit_via_iface, __fieldinfo_list);
00391 }
00392
00393
00394
00395
00396
00397 InterfaceFieldIterator
00398 Message::fields_end()
00399 {
00400 return InterfaceFieldIterator();
00401 }
00402
00403
00404
00405
00406
00407 unsigned int
00408 Message::num_fields() const
00409 {
00410 return __num_fields;
00411 }
00412
00413
00414
00415
00416
00417
00418 Message *
00419 Message::clone() const
00420 {
00421 return new Message(this);
00422 }
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434 void
00435 Message::add_fieldinfo(interface_fieldtype_t type, const char *name,
00436 size_t length, void *value, const char *enumtype)
00437 {
00438 interface_fieldinfo_t *infol = __fieldinfo_list;
00439 interface_fieldinfo_t *newinfo = (interface_fieldinfo_t *)malloc(sizeof(interface_fieldinfo_t));
00440
00441 newinfo->type = type;
00442 newinfo->enumtype = enumtype;
00443 newinfo->name = name;
00444 newinfo->length = length;
00445 newinfo->value = value;
00446 newinfo->next = NULL;
00447
00448 if ( infol == NULL ) {
00449
00450 __fieldinfo_list = newinfo;
00451 } else {
00452
00453 while ( infol->next != NULL ) {
00454 infol = infol->next;
00455 }
00456 infol->next = newinfo;
00457 }
00458
00459 ++__num_fields;
00460 }
00461
00462 }