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         res     = get_long_parameter(CONST_MSG_ID_KEY_NAME, err_flg);
 218         if (*err_flg == PLP_OK) {
 219                 ret_val = res;
 220         }
 221         return ret_val;
 222 }
 223
 224 string BusMessage::get_string_parameter(string arg_name_param, int *err_flg) {
 225         string                  ret_val;
 226         DataItem                *item;
 227         DataItemSequence        *seq;
 228         const char              *ch;
 229
 230         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 231         seq             = (DataItemSequence *)_dataItemSeq;
 232         item            = get_dataitem_by_param_name(seq, arg_name_param);
 233         if (item != NULL) {
 234                 //item->value >>= CORBA::Any::to_string(ch, 0);
 235                 ch              = item->str_value;
 236                 ret_val         = ch;
 237                 *err_flg        = PLP_OK;
 238         }
 239         return ret_val;
 240 }
 241
 242 long BusMessage::get_long_parameter(string arg_name_param, int *err_flg) {
 243         long                    ret_val;
 244         DataItem                *item;
 245         DataItemSequence        *seq;
 246
 247         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 248         seq             = (DataItemSequence *)_dataItemSeq;
 249         item            = get_dataitem_by_param_name(seq, arg_name_param);
 250         if (item != NULL) {
 251                 item->value >>= ret_val;
 252                 *err_flg        = PLP_OK;
 253         }
 254         return ret_val;
 255 }
 256
 257 int BusMessage::get_int_parameter(string arg_name_param, int *err_flg) {
 258         int                     ret_val;
 259         DataItem                *item;
 260         DataItemSequence        *seq;
 261         long                    tmp;
 262
 263         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 264         seq             = (DataItemSequence *)_dataItemSeq;
 265         item            = get_dataitem_by_param_name(seq, arg_name_param);
 266         if (item != NULL) {
 267                 item->value >>= tmp;
 268                 ret_val =        (int)tmp;
 269                 *err_flg        = PLP_OK;
 270         }
 271         return ret_val;
 272 }
 273
 274 double BusMessage::get_double_parameter(string arg_name_param, int *err_flg) {
 275         double          ret_val;
 276         DataItem        *item;
 277         DataItemSequence *seq;
 278
 279         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 280         seq             = (DataItemSequence *)_dataItemSeq;
 281         item            = get_dataitem_by_param_name(seq, arg_name_param);
 282         if (item != NULL) {
 283                 item->value >>= ret_val;
 284                 *err_flg        = PLP_OK;
 285         }
 286         return ret_val;
 287 }
 288
 289 float BusMessage::get_float_parameter(string arg_name_param, int *err_flg) {
 290         float           ret_val;
 291         DataItem        *item;
 292         DataItemSequence *seq;
 293
 294         *err_flg        = PLP_ERR_DATA_NOT_FOUND;
 295         seq             = (DataItemSequence *)_dataItemSeq;
 296         item            = get_dataitem_by_param_name(seq, arg_name_param);
 297         if (item != NULL) {
 298                 item->value >>= ret_val;
 299                 *err_flg        = PLP_OK;
 300         }
 301         return ret_val;
 302 }
 303
 304 void BusMessage::printout_dataitem(long index, void *item) {
 305         CORBA::TCKind   kind;
 306         const char      *name;
 307         DataItem        *dataitem;
 308
 309         dataitem        = (DataItem *)item;
 310         if (item != NULL) {
 311                 if (dataitem->name != NULL) {
 312                         name    = dataitem->name;
 313                         kind    = dataitem->value.type()->kind();
 314                         switch(kind) {
 315                                 case tk_long:
 316                                         {
 317                                                 long    val;
 318                                                 dataitem->value >>= val;
 319                                                 log_debug("\t[%ld] %s: %ld\n", index, name, val);
 320                                                 //val_str       = strdup("long");
 321                                         }
 322                                         break;
 323                                 case tk_double:
 324                                         {
 325                                                 double val;
 326                                                 dataitem->value >>= val;
 327                                                 log_debug("\t[%ld] %s: %f\n", index, name, val);
 328                                                 //val_str       = strdup("double");
 329                                         }
 330                                         break;
 331                                 case tk_float:
 332                                         {
 333                                                 float val;
 334                                                 dataitem->value >>= val;
 335                                                 log_debug("\t[l%ld] %s: %f\n", index, name, val);
 336                                                 //val_str       = strdup("float");
 337                                         }
 338                                         break;
 339                                 default:
 340                                         {
 341                                                 const char *val;
 342                                                 val     = dataitem->str_value;
 343                                                 log_debug("\t[%ld] %s: %s\n", index, name, val);
 344                                         }
 345                                         break;
 346                                         log_error("\t[%ld], name: %s, value unknown\n", index, name);
 347                         }
 348                 }
 349                 else {
 350                         log_error("\t[%ld] Invalid data item name name or value\n", index);
 351                 }
 352         }
 353         else {
 354                 log_error("\t[%ld] dataItem NULL.", index);
 355         }
 356 }
 357
 358 void BusMessage::printout() {
 359         long int                count;
 360         DataItem                item;
 361         DataItemSequence        *seq;
 362
 363         seq     = (DataItemSequence *)_dataItemSeq;
 364         count   = seq->length();
 365         log_debug("BusMessage.printout(): parameter count: %ld\n", count);
 366         for (long ii = 0; ii < count; ii++) {
 367                 printf("item[%ld]\n", ii);
 368                 item    = (*seq)[ii];
 369                 printout_dataitem(ii, &item);
 370         }
 371         log_debug("BusMessage.printout() done\n");;
 372 }