src/plpbus/BusMessage.cc

   1 /*
   2  * BusMessage.cpp
   3  *
   4  *  Created on: Aug 17, 2010
   5  *      Author: lamikr
   6  */
   7
   8 #include <plp/log.h>
   9
  10 #include "BusMessage.hh"
  11 #include "RequestResponseBus.hh"
  12
  13 using namespace std;
  14 using namespace plpbus_orb;
  15 using namespace plpbus;
  16 using namespace CORBA;
  17
  18 #define CONST_MSG_ID_KEY_NAME   "_msgtype"
  19
  20 BusMessage::BusMessage() {
  21         _dataItemSeq    = new DataItemSequence(0);
  22 }
  23
  24 BusMessage::BusMessage(long type_param) {
  25         _dataItemSeq    = new DataItemSequence(0);
  26
  27         add_long_parameter(CONST_MSG_ID_KEY_NAME, type_param);
  28 }
  29
  30 BusMessage::BusMessage(long type_param,
  31                         const char *arg_name_param,
  32                         const char *arg_string_value_param) {
  33         _dataItemSeq    = new DataItemSequence(0);
  34         add_long_parameter(CONST_MSG_ID_KEY_NAME, type_param);
  35         add_string_parameter(arg_name_param, arg_string_value_param);
  36 }
  37
  38 BusMessage::~BusMessage() {
  39 }
  40
  41 int BusMessage::add_string_parameter(const char *arg_name_param, const char *value_param)
  42 {
  43         long                    length;
  44         int                     ret_val;
  45         DataItem                *item;
  46         DataItemSequence        *seq;
  47
  48         ret_val = 0;
  49         seq     = (DataItemSequence *)_dataItemSeq;
  50         if (arg_name_param != NULL) {
  51                 length          = seq->length();
  52                 item            = new DataItem();
  53                 item->name      = strdup(arg_name_param);
  54                 if (value_param != NULL) {
  55                         item->value     <<= strdup(value_param);
  56                         seq->length(length + 1);
  57                         (*seq)[length]  = *item;
  58                 }
  59         }
  60         else {
  61                 ret_val = -1;
  62         }
  63         return ret_val;
  64 }
  65
  66 int BusMessage::add_long_parameter(const char *arg_name_param, long value_param)
  67 {
  68         long                    length;
  69         int                     ret_val;
  70         DataItem                *item;
  71         DataItemSequence        *seq;
  72
  73         ret_val = 0;
  74         seq     = (DataItemSequence *)_dataItemSeq;
  75         if (arg_name_param != NULL) {
  76                 length          = seq->length();
  77                 item            = new DataItem();
  78                 item->name      = strdup(arg_name_param);
  79                 item->value     <<= value_param;
  80
  81                 seq->length(length + 1);
  82                 (*seq)[length]  = *item;
  83         }
  84         else {
  85                 ret_val = -1;
  86         }
  87         return ret_val;
  88 }
  89
  90 int BusMessage::add_int_parameter(const char *arg_name_param, int value_param)
  91 {
  92         long                    length;
  93         int                     ret_val;
  94         DataItem                *item;
  95         DataItemSequence        *seq;
  96
  97         ret_val = 0;
  98         seq     = (DataItemSequence *)_dataItemSeq;
  99         if (arg_name_param != NULL) {
 100                 length          = seq->length();
 101                 item            = new DataItem();
 102                 item->name      = strdup(arg_name_param);
 103                 item->value     <<= (long)value_param;
 104
 105                 seq->length(length + 1);
 106                 (*seq)[length]  = *item;
 107         }
 108         else {
 109                 ret_val = -1;
 110         }
 111         return ret_val;
 112 }
 113
 114 int BusMessage::add_double_parameter(const char *arg_name_param, double value_param)
 115 {
 116         long                    length;
 117         int                     ret_val;
 118         DataItem                *item;
 119         DataItemSequence        *seq;
 120
 121         ret_val = 0;
 122         log_debug("add_double_parameter() started\n");
 123         seq     = (DataItemSequence *)_dataItemSeq;
 124         if (arg_name_param != NULL) {
 125                 length          = seq->length();
 126                 item            = new DataItem();
 127                 item->name      = strdup(arg_name_param);
 128                 item->value     <<= (long)value_param;
 129
 130                 seq->length(length + 1);
 131                 (*seq)[length]  = *item;
 132         }
 133         else {
 134                 ret_val = -1;
 135         }
 136         log_debug("add_double_parameter() done\n");
 137         return ret_val;
 138 }
 139
 140 int BusMessage::add_float_parameter(const char *arg_name_param, float value_param)
 141 {
 142         long                    length;
 143         int                     ret_val;
 144         DataItem                *item;
 145         DataItemSequence        *seq;
 146
 147         ret_val = 0;
 148         seq     = (DataItemSequence *)_dataItemSeq;
 149         if (arg_name_param != NULL) {
 150                 length          = seq->length();
 151                 item            = new DataItem();
 152                 item->name      = strdup(arg_name_param);
 153                 item->value     <<= (long)value_param;
 154
 155                 seq->length(length + 1);
 156                 (*seq)[length]  = *item;
 157         }
 158         else {
 159                 ret_val = -1;
 160         }
 161         return ret_val;
 162 }
 163
 164 static DataItem *get_dataitem_by_param_name(DataItemSequence *seq, const char *arg_name_param) {
 165         DataItem        *ret_val;
 166         long int        count;
 167         DataItem        *item;
 168         const char      *item_name;
 169
 170         ret_val = NULL;
 171         count   = seq->length();
 172         for (long ii = 0; ii < count; ii++) {
 173                 item            = &(*seq)[ii];
 174                 item_name       = item->name;
 175                 if (strcmp(arg_name_param, item_name) == 0) {
 176                         ret_val = item;
 177                         break;
 178                 }
 179         }
 180         return ret_val;
 181 }
 182
 183 bool BusMessage::get_type(long *type_param) {
 184         bool    ret_val;
 185         long    res;
 186
 187         ret_val = get_long_parameter(CONST_MSG_ID_KEY_NAME, &res);
 188         if (ret_val == true) {
 189                 *type_param     = res;
 190         }
 191         return ret_val;
 192 }
 193
 194 bool BusMessage::get_string_parameter(const char *arg_name_param, const char **value_param) {
 195         bool            ret_val;
 196         DataItem        *item;
 197         DataItemSequence *seq;
 198
 199         ret_val = false;
 200         seq     = (DataItemSequence *)_dataItemSeq;
 201         item    = get_dataitem_by_param_name(seq, arg_name_param);
 202         if (item != NULL) {
 203                 item->value >>= *value_param;
 204                 ret_val = true;
 205         }
 206         return ret_val;
 207 }
 208
 209 bool BusMessage::get_long_parameter(const char *arg_name_param, long *value_param) {
 210         bool                    ret_val;
 211         DataItem                *item;
 212         DataItemSequence        *seq;
 213
 214         ret_val = false;
 215         seq     = (DataItemSequence *)_dataItemSeq;
 216         item    = get_dataitem_by_param_name(seq, arg_name_param);
 217         if (item != NULL) {
 218                 item->value >>= *value_param;
 219                 ret_val = true;
 220         }
 221         return ret_val;
 222 }
 223
 224 bool BusMessage::get_int_parameter(const char *arg_name_param, int *value_param) {
 225         bool                    ret_val;
 226         DataItem                *item;
 227         DataItemSequence        *seq;
 228         long                    tmp;
 229
 230         ret_val = false;
 231         seq     = (DataItemSequence *)_dataItemSeq;
 232         item    = get_dataitem_by_param_name(seq, arg_name_param);
 233         if (item != NULL) {
 234                 item->value >>= tmp;
 235                 *value_param    = (int)tmp;
 236                 ret_val = true;
 237         }
 238         return ret_val;
 239 }
 240
 241 bool BusMessage::get_double_parameter(const char *arg_name_param, double *value_param) {
 242         bool            ret_val;
 243         DataItem        *item;
 244         DataItemSequence *seq;
 245
 246         ret_val = false;
 247         seq     = (DataItemSequence *)_dataItemSeq;
 248         item    = get_dataitem_by_param_name(seq, arg_name_param);
 249         if (item != NULL) {
 250                 item->value >>= *value_param;
 251                 ret_val = true;
 252         }
 253         return ret_val;
 254 }
 255
 256 bool BusMessage::get_float_parameter(const char *arg_name_param, float *value_param) {
 257         bool            ret_val;
 258         DataItem        *item;
 259         DataItemSequence *seq;
 260
 261         ret_val = false;
 262         seq     = (DataItemSequence *)_dataItemSeq;
 263         item    = get_dataitem_by_param_name(seq, arg_name_param);
 264         if (item != NULL) {
 265                 item->value >>= *value_param;
 266                 ret_val = true;
 267         }
 268         return ret_val;
 269 }
 270
 271 void BusMessage::printout_dataitem(long index, void *item) {
 272         CORBA::TCKind   kind;
 273         const char      *name;
 274         DataItem        *dataitem;
 275
 276         dataitem        = (DataItem *)item;
 277         if (item != NULL) {
 278                 if (dataitem->name != NULL) {
 279                         name    = dataitem->name;
 280                         kind    = dataitem->value.type()->kind();
 281                         switch(kind) {
 282                                 case tk_string:
 283                                         {
 284                                                 const char *val;
 285
 286                                                 dataitem->value >>= val;
 287                                                 log_debug("\t[%ld] %s: %s\n", index, name, val);
 288                                         }
 289                                         break;
 290                                 case tk_long:
 291                                         {
 292                                                 long    val;
 293                                                 dataitem->value >>= val;
 294                                                 log_debug("\t[%ld] %s: %ld\n", index, name, val);
 295                                                 //val_str       = strdup("long");
 296                                         }
 297                                         break;
 298                                 case tk_double:
 299                                         {
 300                                                 double val;
 301                                                 dataitem->value >>= val;
 302                                                 log_debug("\t[%ld] %s: %f\n", index, name, val);
 303                                                 //val_str       = strdup("double");
 304                                         }
 305                                         break;
 306                                 case tk_float:
 307                                         {
 308                                                 float val;
 309                                                 dataitem->value >>= val;
 310                                                 log_debug("\t[l%ld] %s: %f\n", index, name, val);
 311                                                 //val_str       = strdup("float");
 312                                         }
 313                                         break;
 314                                 default:
 315                                         log_error("\t[%ld], name: %s, value unknown\n", index, name);
 316                         }
 317                 }
 318                 else {
 319                         log_error("\t[%ld] Invalid data item name name or value\n", index);
 320                 }
 321         }
 322         else {
 323                 log_error("\t[%ld] dataItem NULL.", index);
 324         }
 325 }
 326
 327 void BusMessage::printout() {
 328         long int                count;
 329         DataItem                item;
 330         DataItemSequence        *seq;
 331
 332         seq     = (DataItemSequence *)_dataItemSeq;
 333         count   = seq->length();
 334         log_debug("BusMessage.printout(): parameter count: %ld\n", count);
 335         for (long ii = 0; ii < count; ii++) {
 336                 item    = (*seq)[ii];
 337                 printout_dataitem(ii, &item);
 338         }
 339         log_debug("BusMessage.printout() done\n");;
 340 }