src/plpbus/BusMessage.cc

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