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         long                    cnt;
  44         DataItemSequence        *seq;
  45
  46         log_debug("BusMessage DESTRUCTOR\n");
  47         seq     = (DataItemSequence *)_dataItemSeq;
  48         if (seq != NULL) {
  49                 cnt     = seq->length();
  50 /*
  51                 DataItem                *item;
  52
  53                 for (long ii = 0; ii < cnt; ii++) {
  54                         item    = seq[ii];
  55                         log_debug("deleting BusMessage item:\n");
  56                         printout_dataitem(ii, item);
  57                         delete(item);
  58                 }
  59 */
  60                 delete(seq);
  61         }
  62 }
  63
  64 int BusMessage::add_cstring_parameter(const char *arg_name_param, const char *value_param) {
  65         long                    ln;
  66         int                     ret_val;
  67         DataItemSequence        *seq;
  68         DataItem                *item;
  69
  70         ret_val = 0;
  71         seq     = (DataItemSequence *)_dataItemSeq;
  72         if (arg_name_param != NULL) {
  73                 ln                      = seq->length();
  74                 seq->length(ln + 1);
  75                 item                    = &((*seq)[ln]);
  76                 item->name              = arg_name_param;
  77                 item->str_value         = value_param;
  78         }
  79         else {
  80                 ret_val = -1;
  81         }
  82         return ret_val;
  83 }
  84
  85 int BusMessage::add_string_parameter(string arg_name_param, string value_param)
  86 {
  87         long                    ln;
  88         int                     ret_val;
  89         DataItemSequence        *seq;
  90         DataItem                *item;
  91
  92         //str   = (const char)"hooo";
  93         ret_val = 0;
  94         seq     = (DataItemSequence *)_dataItemSeq;
  95         if (arg_name_param.empty() == false) {
  96                 ln              = seq->length();
  97                 seq->length(ln + 1);
  98                 item            = &((*seq)[ln]);
  99                 item->name      = arg_name_param.c_str();
 100                 item->str_value = value_param.c_str();
 101         }
 102         else {
 103                 ret_val = -1;
 104         }
 105         return ret_val;
 106 }
 107
 108 int BusMessage::add_long_parameter(string arg_name_param, long value_param)
 109 {
 110         long                    length;
 111         int                     ret_val;
 112         DataItemSequence        *seq;
 113
 114         ret_val = 0;
 115         seq     = (DataItemSequence *)_dataItemSeq;
 116         if (arg_name_param.empty() == false) {
 117                 length          = seq->length();
 118                 seq->length(length + 1);
 119                 (*seq)[length].name     = arg_name_param.c_str();
 120                 (*seq)[length].value    <<= value_param;
 121                 (*seq)[length].str_value = "";
 122         }
 123         else {
 124                 ret_val = -1;
 125         }
 126         return ret_val;
 127 }
 128
 129 int BusMessage::add_int_parameter(string arg_name_param, int value_param)
 130 {
 131         long                    length;
 132         int                     ret_val;
 133         DataItemSequence        *seq;
 134
 135         ret_val = 0;
 136         seq     = (DataItemSequence *)_dataItemSeq;
 137         if (arg_name_param.empty() == false) {
 138                 length          = seq->length();
 139                 seq->length(length + 1);
 140                 (*seq)[length].name     = arg_name_param.c_str();
 141                 (*seq)[length].value    <<= (long)value_param;
 142                 (*seq)[length].str_value = "";
 143         }
 144         else {
 145                 ret_val = -1;
 146         }
 147         return ret_val;
 148 }
 149
 150 int BusMessage::add_double_parameter(string arg_name_param, double value_param)
 151 {
 152         long                    length;
 153         int                     ret_val;
 154         DataItemSequence        *seq;
 155
 156         ret_val = 0;
 157         log_debug("add_double_parameter() started\n");
 158         seq     = (DataItemSequence *)_dataItemSeq;
 159         if (arg_name_param.empty() == false) {
 160                 length          = seq->length();
 161                 seq->length(length + 1);
 162                 (*seq)[length].name     = arg_name_param.c_str();
 163                 (*seq)[length].value    <<= (double)value_param;
 164                 (*seq)[length].str_value = "";
 165         }
 166         else {
 167                 ret_val = -1;
 168         }
 169         log_debug("add_double_parameter() done\n");
 170         return ret_val;
 171 }
 172
 173 int BusMessage::add_float_parameter(string arg_name_param, float value_param)
 174 {
 175         long                    length;
 176         int                     ret_val;
 177         DataItemSequence        *seq;
 178
 179         ret_val = 0;
 180         seq     = (DataItemSequence *)_dataItemSeq;
 181         if (arg_name_param.empty() == false) {
 182                 length          = seq->length();
 183                 seq->length(length + 1);
 184                 (*seq)[length].name     = arg_name_param.c_str();
 185                 (*seq)[length].value    <<= (float)value_param;
 186                 (*seq)[length].str_value = "";
 187         }
 188         else {
 189                 ret_val = -1;
 190         }
 191         return ret_val;
 192 }
 193
 194 static DataItem *get_dataitem_by_param_name(DataItemSequence *seq, string arg_name_param) {
 195         DataItem        *ret_val;
 196         long int        count;
 197         DataItem        *item;
 198         const char      *item_name;
 199
 200         ret_val = NULL;
 201         count   = seq->length();
 202         for (long ii = 0; ii < count; ii++) {
 203                 item            = &(*seq)[ii];
 204                 item_name       = item->name;
 205                 if (strcmp(arg_name_param.c_str(), item_name) == 0) {
 206                         ret_val = item;
 207                         break;
 208                 }
 209         }
 210         return ret_val;
 211 }
 212
 213 long BusMessage::get_type(int *err_flg) {
 214         long    ret_val;
 215         long    res;
 216
 217         ret_val = -1;
 218         res     = get_long_parameter(CONST_MSG_ID_KEY_NAME, err_flg);
 219         if (*err_flg == PLP_OK) {
 220                 ret_val = res;
 221         }
 222         return ret_val;
 223 }
 224
 225 string BusMessage::get_string_parameter(string arg_name_param, int *err_flg) {
 226         string                  ret_val;
 227         DataItem                *item;
 228         DataItemSequence        *seq;
 229         const char              *ch;
 230
 231         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 232         seq             = (DataItemSequence *)_dataItemSeq;
 233         item            = get_dataitem_by_param_name(seq, arg_name_param);
 234         if (item != NULL) {
 235                 //item->value >>= CORBA::Any::to_string(ch, 0);
 236                 ch              = item->str_value;
 237                 ret_val         = ch;
 238                 *err_flg        = PLP_OK;
 239         }
 240         return ret_val;
 241 }
 242
 243 long BusMessage::get_long_parameter(string arg_name_param, int *err_flg) {
 244         long                    ret_val;
 245         DataItem                *item;
 246         DataItemSequence        *seq;
 247
 248         ret_val         = 0;
 249         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 250         seq             = (DataItemSequence *)_dataItemSeq;
 251         item            = get_dataitem_by_param_name(seq, arg_name_param);
 252         if (item != NULL) {
 253                 item->value >>= ret_val;
 254                 *err_flg        = PLP_OK;
 255         }
 256         return ret_val;
 257 }
 258
 259 int BusMessage::get_int_parameter(string arg_name_param, int *err_flg) {
 260         int                     ret_val;
 261         DataItem                *item;
 262         DataItemSequence        *seq;
 263         long                    tmp;
 264
 265         ret_val         = 0;
 266         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 267         seq             = (DataItemSequence *)_dataItemSeq;
 268         item            = get_dataitem_by_param_name(seq, arg_name_param);
 269         if (item != NULL) {
 270                 item->value >>= tmp;
 271                 ret_val =        (int)tmp;
 272                 *err_flg        = PLP_OK;
 273         }
 274         return ret_val;
 275 }
 276
 277 double BusMessage::get_double_parameter(string arg_name_param, int *err_flg) {
 278         double          ret_val;
 279         DataItem        *item;
 280         DataItemSequence *seq;
 281
 282         ret_val         = 0;
 283         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 284         seq             = (DataItemSequence *)_dataItemSeq;
 285         item            = get_dataitem_by_param_name(seq, arg_name_param);
 286         if (item != NULL) {
 287                 item->value >>= ret_val;
 288                 *err_flg        = PLP_OK;
 289         }
 290         return ret_val;
 291 }
 292
 293 float BusMessage::get_float_parameter(string arg_name_param, int *err_flg) {
 294         float           ret_val;
 295         DataItem        *item;
 296         DataItemSequence *seq;
 297
 298         ret_val         = 0;
 299         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 300         seq             = (DataItemSequence *)_dataItemSeq;
 301         item            = get_dataitem_by_param_name(seq, arg_name_param);
 302         if (item != NULL) {
 303                 item->value >>= ret_val;
 304                 *err_flg        = PLP_OK;
 305         }
 306         return ret_val;
 307 }
 308
 309 void BusMessage::printout_dataitem(long index, void *item) {
 310         CORBA::TCKind   kind;
 311         const char      *name;
 312         DataItem        *dataitem;
 313
 314         dataitem        = (DataItem *)item;
 315         if (item != NULL) {
 316                 if (dataitem->name != NULL) {
 317                         name    = dataitem->name;
 318                         kind    = dataitem->value.type()->kind();
 319                         switch(kind) {
 320                                 case tk_long:
 321                                         {
 322                                                 long    val;
 323                                                 dataitem->value >>= val;
 324                                                 log_debug("\t[%ld] %s: %ld\n", index, name, val);
 325                                                 //val_str       = strdup("long");
 326                                         }
 327                                         break;
 328                                 case tk_double:
 329                                         {
 330                                                 double val;
 331                                                 dataitem->value >>= val;
 332                                                 log_debug("\t[%ld] %s: %f\n", index, name, val);
 333                                                 //val_str       = strdup("double");
 334                                         }
 335                                         break;
 336                                 case tk_float:
 337                                         {
 338                                                 float val;
 339                                                 dataitem->value >>= val;
 340                                                 log_debug("\t[l%ld] %s: %f\n", index, name, val);
 341                                                 //val_str       = strdup("float");
 342                                         }
 343                                         break;
 344                                 default:
 345                                         {
 346                                                 const char *val;
 347                                                 val     = dataitem->str_value;
 348                                                 log_debug("\t[%ld] %s: %s\n", index, name, val);
 349                                         }
 350                                         break;
 351                                         log_error("\t[%ld], name: %s, value unknown\n", index, name);
 352                         }
 353                 }
 354                 else {
 355                         log_error("\t[%ld] Invalid data item name name or value\n", index);
 356                 }
 357         }
 358         else {
 359                 log_error("\t[%ld] dataItem NULL.", index);
 360         }
 361 }
 362
 363 void BusMessage::printout() {
 364         long int                count;
 365         DataItem                item;
 366         DataItemSequence        *seq;
 367
 368         seq     = (DataItemSequence *)_dataItemSeq;
 369         count   = seq->length();
 370         log_debug("BusMessage.printout(): parameter count: %ld\n", count);
 371         for (long ii = 0; ii < count; ii++) {
 372                 printf("item[%ld]\n", ii);
 373                 item    = (*seq)[ii];
 374                 printout_dataitem(ii, &item);
 375         }
 376         log_debug("BusMessage.printout() done\n");;
 377 }