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 BusMessage::BusMessage() {
  19         _dataItemSeq    = new DataItemSequence(0);
  20 }
  21
  22 BusMessage::BusMessage(long type_param) {
  23         _dataItemSeq    = new DataItemSequence(0);
  24
  25         add_long_parameter(CONST_MSG_ID_KEY_NAME, type_param);
  26 }
  27
  28 BusMessage::BusMessage(long type_param,
  29                         const char *arg_name_param,
  30                         const char *arg_string_value_param) {
  31         _dataItemSeq    = new DataItemSequence(0);
  32         add_long_parameter(CONST_MSG_ID_KEY_NAME, type_param);
  33         add_string_parameter(arg_name_param, arg_string_value_param);
  34 }
  35
  36 BusMessage::~BusMessage() {
  37 }
  38
  39 int BusMessage::add_string_parameter(const char *arg_name_param, const char *value_param)
  40 {
  41         long                    length;
  42         int                     ret_val;
  43         DataItem                *item;
  44         DataItemSequence        *seq;
  45
  46         ret_val = 0;
  47         seq     = (DataItemSequence *)_dataItemSeq;
  48         if (arg_name_param != NULL) {
  49                 length          = seq->length();
  50                 item            = new DataItem();
  51                 item->name      = strdup(arg_name_param);
  52                 if (value_param != NULL) {
  53                         item->value     <<= strdup(value_param);
  54                         seq->length(length + 1);
  55                         (*seq)[length]  = *item;
  56                 }
  57         }
  58         else {
  59                 ret_val = -1;
  60         }
  61         return ret_val;
  62 }
  63
  64 int BusMessage::add_long_parameter(const char *arg_name_param, long value_param)
  65 {
  66         long                    length;
  67         int                     ret_val;
  68         DataItem                *item;
  69         DataItemSequence        *seq;
  70
  71         ret_val = 0;
  72         seq     = (DataItemSequence *)_dataItemSeq;
  73         if (arg_name_param != NULL) {
  74                 length          = seq->length();
  75                 item            = new DataItem();
  76                 item->name      = strdup(arg_name_param);
  77                 item->value     <<= value_param;
  78
  79                 seq->length(length + 1);
  80                 (*seq)[length]  = *item;
  81         }
  82         else {
  83                 ret_val = -1;
  84         }
  85         return ret_val;
  86 }
  87
  88 int BusMessage::add_int_parameter(const char *arg_name_param, int value_param)
  89 {
  90         long                    length;
  91         int                     ret_val;
  92         DataItem                *item;
  93         DataItemSequence        *seq;
  94
  95         ret_val = 0;
  96         seq     = (DataItemSequence *)_dataItemSeq;
  97         if (arg_name_param != NULL) {
  98                 length          = seq->length();
  99                 item            = new DataItem();
 100                 item->name      = strdup(arg_name_param);
 101                 item->value     <<= (long)value_param;
 102
 103                 seq->length(length + 1);
 104                 (*seq)[length]  = *item;
 105         }
 106         else {
 107                 ret_val = -1;
 108         }
 109         return ret_val;
 110 }
 111
 112 int BusMessage::add_double_parameter(const char *arg_name_param, double value_param)
 113 {
 114         long                    length;
 115         int                     ret_val;
 116         DataItem                *item;
 117         DataItemSequence        *seq;
 118
 119         ret_val = 0;
 120         log_debug("add_double_parameter() started\n");
 121         seq     = (DataItemSequence *)_dataItemSeq;
 122         if (arg_name_param != NULL) {
 123                 length          = seq->length();
 124                 item            = new DataItem();
 125                 item->name      = strdup(arg_name_param);
 126                 item->value     <<= (long)value_param;
 127
 128                 seq->length(length + 1);
 129                 (*seq)[length]  = *item;
 130         }
 131         else {
 132                 ret_val = -1;
 133         }
 134         log_debug("add_double_parameter() done\n");
 135         return ret_val;
 136 }
 137
 138 int BusMessage::add_float_parameter(const char *arg_name_param, float value_param)
 139 {
 140         long                    length;
 141         int                     ret_val;
 142         DataItem                *item;
 143         DataItemSequence        *seq;
 144
 145         ret_val = 0;
 146         seq     = (DataItemSequence *)_dataItemSeq;
 147         if (arg_name_param != NULL) {
 148                 length          = seq->length();
 149                 item            = new DataItem();
 150                 item->name      = strdup(arg_name_param);
 151                 item->value     <<= (long)value_param;
 152
 153                 seq->length(length + 1);
 154                 (*seq)[length]  = *item;
 155         }
 156         else {
 157                 ret_val = -1;
 158         }
 159         return ret_val;
 160 }
 161
 162 void BusMessage::printout_dataitem(long index, void *item) {
 163         CORBA::TCKind   kind;
 164         DataItem        *dataitem;
 165
 166         dataitem        = (DataItem *)item;
 167         if (item != NULL) {
 168                 if (dataitem->name != NULL) {
 169                         kind    = dataitem->value.type()->kind();
 170                         switch(kind) {
 171                                 case tk_string:
 172                                         {
 173                                                 const char *val;
 174
 175                                                 dataitem->value >>= val;
 176                                                 log_debug("\t[%ld], value: %s\n", index, val);
 177                                         }
 178                                         break;
 179                                 case tk_long:
 180                                         {
 181                                                 long    val;
 182                                                 dataitem->value >>= val;
 183                                                 log_debug("\t[%ld], value: %ld\n", index, val);
 184                                                 //val_str       = strdup("long");
 185                                         }
 186                                         break;
 187                                 case tk_double:
 188                                         {
 189                                                 double val;
 190                                                 dataitem->value >>= val;
 191                                                 log_debug("\t[%ld], value: %f\n", index, val);
 192                                                 //val_str       = strdup("double");
 193                                         }
 194                                         break;
 195                                 case tk_float:
 196                                         {
 197                                                 float val;
 198                                                 dataitem->value >>= val;
 199                                                 log_debug("\t[l%ld] value: %f\n", index, val);
 200                                                 //val_str       = strdup("float");
 201                                         }
 202                                         break;
 203                                 default:
 204                                         log_error("\t[%ld], value unknown\n", index);
 205                         }
 206                 }
 207                 else {
 208                         log_error("\t[%ld] Invalid data item name name or value\n", index);
 209                 }
 210         }
 211         else {
 212                 log_error("\t[%ld] dataItem NULL.", index);
 213         }
 214 }
 215
 216 void BusMessage::printout() {
 217         long int                count;
 218         DataItem                item;
 219         DataItemSequence        *seq;
 220
 221         seq     = (DataItemSequence *)_dataItemSeq;
 222         count   = seq->length();
 223         log_debug("BusMessage.printout(): parameter count: %ld\n", count);
 224         for (long ii = 0; ii < count; ii++) {
 225                 item    = (*seq)[ii];
 226                 printout_dataitem(ii, &item);
 227         }
 228         log_debug("BusMessage.printout() done\n");;
 229 }