cMsgPayload.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------------*
*  Copyright (c) 2007        Jefferson Science Associates,                   *
*                            Thomas Jefferson National Accelerator Facility  *
*                                                                            *
*    This software was developed under a United States Government license    *
*    described in the NOTICE file included as part of this distribution.     *
*                                                                            *
*    C.Timmer, 3-Aug-2007, Jefferson Lab                                     *
*                                                                            *
*    Authors: Carl Timmer                                                    *
*             timmer@jlab.org                   Jefferson Lab, MS-12B3       *
*             Phone: (757) 269-5130             12000 Jefferson Ave.         *
*             Fax:   (757) 269-6248             Newport News, VA 23606       *
*                                                                            *
*----------------------------------------------------------------------------*/
 
 
#include <cMsg.hxx>
#include <cMsgPrivate.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <vector>
#include <map>
#include <sstream>
 
using namespace std;
using namespace cmsg;
 
namespace cmsg {
 
    //-----------------------------------------------------------------------------
    //  cMsgPayload methods
    //-----------------------------------------------------------------------------
 
 
    //-----------------------------------------------------------------------------
 
    void cMsgMessage::payloadClear(void) {
        cMsgPayloadClear(myMsgPointer);
    }
 
    //-----------------------------------------------------------------------------
 
    void cMsgMessage::payloadReset(void) {
        cMsgPayloadReset(myMsgPointer);
    }
 
    //-------------------------------------------------------------------
 
    void cMsgMessage::payloadPrint(void) const {
        cMsgPayloadPrint(myMsgPointer);
    }
 
    //-------------------------------------------------------------------
 
    bool cMsgMessage::hasPayload() const {
        int hasPayload;
        cMsgHasPayload(myMsgPointer, &hasPayload);
        return hasPayload ? true : false;
    }
 
    //-------------------------------------------------------------------
 
    bool cMsgMessage::payloadContainsName(const string &name) const {
        return cMsgPayloadContainsName(myMsgPointer, name.c_str()) ? true : false;
    }
 
    //-------------------------------------------------------------------
 
    int cMsgMessage::payloadGetCount() const {
        int count;
        cMsgPayloadGetCount(myMsgPointer, &count);
        return count;
    }
 
    //-------------------------------------------------------------------
 
    int cMsgMessage::payloadGetType(const string &name) const
            {
        int err, type;
        err = cMsgPayloadGetType(myMsgPointer, name.c_str(), &type);
        if (err != CMSG_OK) {
            if (err == CMSG_BAD_ARGUMENT)
                throw(cMsgException("Name is null"));
            else
              throw(cMsgException(string("No payload item named ") + name));
        }
        return type;
    }
 
    //-------------------------------------------------------------------
 
    void cMsgMessage::payloadCopy(const cMsgMessage &msg) {
        int err = cMsgPayloadCopy(msg.myMsgPointer, myMsgPointer);
        if (err!= CMSG_OK) {
            throw(cMsgException(cMsgPerror(err),err));
        }
    }
 
    //-------------------------------------------------------------------
 
    string cMsgMessage::payloadGetText() const {
        const char *txt;
        cMsgGetPayloadText(myMsgPointer, &txt);
        string s(txt);
        return s;
    }
 
    //-------------------------------------------------------------------
 
    void cMsgMessage::payloadSetFromText(const string &txt)
          {
        int err = cMsgPayloadSetAllFieldsFromText(myMsgPointer, txt.c_str());
        if (err != CMSG_OK) {
            throw(cMsgException(cMsgPerror(err),err));
        }
        return;
    }
 
    //-------------------------------------------------------------------
 
    string cMsgMessage::payloadGetFieldDescription(const string &name) const
            {
        const char *field = cMsgPayloadFieldDescription(myMsgPointer, name.c_str());
        if (field == NULL) {
            string err("No such field as ");
            err += field;
            throw(cMsgException(err));
        }
        string s(field);
        return s;
    }
 
    //-------------------------------------------------------------------
 
    map<string,int> *cMsgMessage::payloadGet() const {
        char **names;
        int *types, len;
 
        int err = cMsgPayloadGetInfo(myMsgPointer, &names, &types, &len);
        if (err != CMSG_OK) {
            if (err == CMSG_BAD_ARGUMENT)
                throw(cMsgException("Name is null"));
            else if (err == CMSG_ERROR)
                throw(cMsgException("No payload exists"));
            else
                throw(cMsgException("Out of memory"));
        }
 
        map<string,int> *mp = new map<string,int>;
        for (int i=0; i<len; i++) {
            (*mp)[names[i]] = types[i];
        }
        return mp;
    }
 
    //-------------------------------------------------------------------
 
    bool cMsgMessage::payloadRemoveField(const string &name) {
        return cMsgPayloadRemove(myMsgPointer, name.c_str()) == 0 ? false : true;
    }
 
 
    //-------------------------------------------------------------------
 
    void cMsgMessage::setHistoryLengthMax(int len) const {
        int err = cMsgSetHistoryLengthMax(myMsgPointer, len);
        if (err != CMSG_OK) throw (cMsgException("len must be >= 0 and < CMSG_HISTORY_LENGTH_ABS_MAX"));
    }
 
 
//-------------------------------------------------------------------
// GET VALUE METHODS
//-------------------------------------------------------------------
 
//-------------------------------------------------------------------
// BINARY
//-------------------------------------------------------------------
 
void cMsgMessage::getBinary(const string &name, const char **val, int &len, int &endian)
        const {
    int err = cMsgGetBinary(myMsgPointer, name.c_str(), val, &len, &endian);
    if (err != CMSG_OK) {
        if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type"));
        else throw(cMsgException(string("No payload item named ") + name));
    }
    return;
}
 
void cMsgMessage::getBinaryArray(const string &name, const char ***vals,
                                 int **lens, int **endians, int &count)
        const {
    int err = cMsgGetBinaryArray(myMsgPointer, name.c_str(), vals, lens, endians, &count);
    if (err != CMSG_OK) {
        if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type"));
        else throw(cMsgException(string("No payload item named ") + name));
    }
    return;
}
 
//-------------------------------------------------------------------
// CMSG MESSAGES
//-------------------------------------------------------------------
 
cMsgMessage *cMsgMessage::getMessage(const string &name) const {
  const void *val;
  int err = cMsgGetMessage(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type"));
    else throw(cMsgException(string("No payload item named ") + name));
  }
 
  // copy message
  void *newMsgPointer=cMsgCopyMessage(val);
  if(newMsgPointer==NULL)
    throw(cMsgException("?cMsgMessage::getMessage...unable to create new message from message contents",CMSG_ERROR));
 
  return(new cMsgMessage(newMsgPointer));
}
 
 
//-------------------------------------------------------------------
 
 
vector<cMsgMessage*> *cMsgMessage::getMessagePVector(const string &name) const {
  int len;
  const void **vals;
  int err = cMsgGetMessageArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  
 
  // fill new vector with message copies
  vector<cMsgMessage*> *msgPVec = new vector<cMsgMessage*>;
  for (int i=0; i<len; i++) msgPVec->push_back(new cMsgMessage(cMsgCopyMessage(vals[i])));
 
  return(msgPVec);
}
 
 
//-------------------------------------------------------------------
 
 
vector<cMsgMessage> *cMsgMessage::getMessageVector(const string &name) const {
  int len;
  const void **vals;
  int err = cMsgGetMessageArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  
 
  // fill new vector with message copies
  vector<cMsgMessage> *msgVec = new vector<cMsgMessage>;
  for (int i=0; i<len; i++) msgVec->push_back(cMsgMessage(cMsgCopyMessage(vals[i])));
 
  return(msgVec);
}
 
 
//-------------------------------------------------------------------
 
 
cMsgMessage* *cMsgMessage::getMessagePArray(const string &name) const {
  int len;
  const void **vals;
  int err = cMsgGetMessageArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  
  // create and fill array with pointers to message copies
  cMsgMessage* *msgPArray = new cMsgMessage*[len];
  for (int i=0; i<len; i++) msgPArray[i]=(new cMsgMessage(cMsgCopyMessage(vals[i])));
 
  return(msgPArray);
}
 
 
//-------------------------------------------------------------------
 
 
cMsgMessage *cMsgMessage::getMessageArray(const string &name) const {
  int len;
  const void **vals;
  int err = cMsgGetMessageArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  
  // create and fill array with message copies
  cMsgMessage *msgArray = new cMsgMessage[len];
  for (int i=0; i<len; i++) msgArray[i]=(cMsgMessage(cMsgCopyMessage(vals[i])));
 
  return(msgArray);
}
 
 
//-------------------------------------------------------------------
// STRINGS
//-------------------------------------------------------------------
 
string cMsgMessage::getString(const string &name) const {
  const char *val;
  int err = cMsgGetString(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  string s(val);
  return s;
}
 
 
//-------------------------------------------------------------------
 
 
vector<string> *cMsgMessage::getStringVector(const string &name) const {
  int len;
  const char **vals;
  int err = cMsgGetStringArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  
  // copy array values and put into a vector
  vector<string> *strs = new vector<string>;
  for (int i=0; i<len; i++) strs->push_back(string(vals[i]));
  return strs;
}
 
 
//-------------------------------------------------------------------
 
 
string *cMsgMessage::getStringArray(const string &name) const {
  int len;
  const char **vals;
  int err = cMsgGetStringArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  
  // place strings into new array
  string *strs = new string[len];
  for (int i=0; i<len; i++) strs[i]=string(vals[i]);
  return strs;
}
 
 
//-------------------------------------------------------------------
// REALS
//-------------------------------------------------------------------
 
float cMsgMessage::getFloat(const string &name) const {
  float val;
  int err = cMsgGetFloat(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
 
double cMsgMessage::getDouble(const string &name) const {
  double val;
  int err = cMsgGetDouble(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
// REAL ARRAYS
//-------------------------------------------------------------------
 
 
vector<float> *cMsgMessage::getFloatVector(const string &name) const {
  int len;
  const float *vals;
  int err = cMsgGetFloatArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<float> *flts = new vector<float>;
  for (int i=0; i<len; i++) flts->push_back(vals[i]);
  return flts;
}
 
 
//-------------------------------------------------------------------
 
 
float *cMsgMessage::getFloatArray(const string &name) const {
  int len;
  const float *vals;
  int err = cMsgGetFloatArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
 
  // copy values into a new array
  float *flts = new float[len];
  for (int i=0; i<len; i++) flts[i]=vals[i];
  return flts;
}
 
 
//-------------------------------------------------------------------
 
 
vector<double> *cMsgMessage::getDoubleVector(const string &name) const {
  int len;
  const double *vals;
  int err = cMsgGetDoubleArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type"));
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<double> *dbls = new vector<double>;
  for (int i=0; i<len; i++) dbls->push_back(vals[i]);
  return dbls;
}
 
 
 
//-------------------------------------------------------------------
 
 
double *cMsgMessage::getDoubleArray(const string &name) const {
  int len;
  const double *vals;
  int err = cMsgGetDoubleArray(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type"));
    else throw(cMsgException(string("No payload item named ") + name));
  }
 
  // put values into new array
  double *dbls = new double[len];
  for (int i=0; i<len; i++) dbls[i]=vals[i];
  return dbls;
}
 
 
//-------------------------------------------------------------------
// INTS
//-------------------------------------------------------------------
 
int8_t cMsgMessage::getInt8(const string &name) const {
  int8_t val;
  int err = cMsgGetInt8(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
 
int16_t cMsgMessage::getInt16(const string &name) const {
  int16_t val;
  int err = cMsgGetInt16(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
 
int32_t cMsgMessage::getInt32(const string &name) const {
  int32_t val;
  int err = cMsgGetInt32(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
 
int64_t cMsgMessage::getInt64(const string &name) const {
  int64_t val;
  int err = cMsgGetInt64(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
 
uint8_t cMsgMessage::getUint8(const string &name) const {
  uint8_t val;
  int err = cMsgGetUint8(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
 
uint16_t cMsgMessage::getUint16(const string &name) const {
  uint16_t val;
  int err = cMsgGetUint16(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
 
uint32_t cMsgMessage::getUint32(const string &name) const {
  uint32_t val;
  int err = cMsgGetUint32(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
 
uint64_t cMsgMessage::getUint64(const string &name) const {
  uint64_t val;
  int err = cMsgGetUint64(myMsgPointer, name.c_str(), &val);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  return val;
}
 
//-------------------------------------------------------------------
// INT ARRAYS & VECTORS
//-------------------------------------------------------------------
 
vector<int8_t> *cMsgMessage::getInt8Vector(const string &name) const {
  int len;
  const int8_t *vals;
  int err = cMsgGetInt8Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<int8_t> *ints = new vector<int8_t>;
  for (int i=0; i<len; i++) ints->push_back(vals[i]);
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
int8_t *cMsgMessage::getInt8Array(const string &name) const {
  int len;
  const int8_t *vals;
  int err = cMsgGetInt8Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put values into new array
  int8_t *ints = new int8_t[len];
  for (int i=0; i<len; i++) ints[i]=vals[i];
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
vector<int16_t> *cMsgMessage::getInt16Vector(const string &name) const {
  int len;
  const int16_t *vals;
  int err = cMsgGetInt16Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<int16_t> *ints = new vector<int16_t>;
  for (int i=0; i<len; i++) ints->push_back(vals[i]);
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
int16_t *cMsgMessage::getInt16Array(const string &name) const {
  int len;
  const int16_t *vals;
  int err = cMsgGetInt16Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put values into new array
  int16_t *ints = new int16_t[len];
  for (int i=0; i<len; i++) ints[i]=vals[i];
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
vector<int32_t> *cMsgMessage::getInt32Vector(const string &name) const {
  int len;
  const int32_t *vals;
  int err = cMsgGetInt32Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<int32_t> *ints = new vector<int32_t>;
  for (int i=0; i<len; i++) ints->push_back(vals[i]);
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
int32_t *cMsgMessage::getInt32Array(const string &name) const {
  int len;
  const int32_t *vals;
  int err = cMsgGetInt32Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put values into new array
  int32_t *ints = new int32_t[len];
  for (int i=0; i<len; i++) ints[i]=vals[i];
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
vector<int64_t> *cMsgMessage::getInt64Vector(const string &name) const {
  int len;
  const int64_t *vals;
  int err = cMsgGetInt64Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<int64_t> *ints = new vector<int64_t>;
  for (int i=0; i<len; i++) ints->push_back(vals[i]);
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
int64_t *cMsgMessage::getInt64Array(const string &name) const {
  int len;
  const int64_t *vals;
  int err = cMsgGetInt64Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put values into new array 
  int64_t *ints = new int64_t[len];
  for (int i=0; i<len; i++) ints[i]=vals[i];
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
vector<uint8_t> *cMsgMessage::getUint8Vector(const string &name) const {
  int len;
  const uint8_t *vals;
  int err = cMsgGetUint8Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<uint8_t> *ints = new vector<uint8_t>;
  for (int i=0; i<len; i++) ints->push_back(vals[i]);
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
uint8_t *cMsgMessage::getUint8Array(const string &name) const {
  int len;
  const uint8_t *vals;
  int err = cMsgGetUint8Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put values into new array
  uint8_t *ints = new uint8_t[len];
  for (int i=0; i<len; i++) ints[i]=vals[i];
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
vector<uint16_t> *cMsgMessage::getUint16Vector(const string &name) const {
  int len;
  const uint16_t *vals;
  int err = cMsgGetUint16Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<uint16_t> *ints = new vector<uint16_t>;
  for (int i=0; i<len; i++) ints->push_back(vals[i]);
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
uint16_t *cMsgMessage::getUint16Array(const string &name) const {
  int len;
  const uint16_t *vals;
  int err = cMsgGetUint16Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put values into new array
  uint16_t *ints = new uint16_t[len];
  for (int i=0; i<len; i++) ints[i]=vals[i];
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
vector<uint32_t> *cMsgMessage::getUint32Vector(const string &name) const {
  int len;
  const uint32_t *vals;
  int err = cMsgGetUint32Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<uint32_t> *ints = new vector<uint32_t>;
  for (int i=0; i<len; i++) ints->push_back(vals[i]);
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
uint32_t *cMsgMessage::getUint32Array(const string &name) const {
  int len;
  const uint32_t *vals;
  int err = cMsgGetUint32Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put values into new array
  uint32_t *ints = new uint32_t[len];
  for (int i=0; i<len; i++) ints[i]=vals[i];
  return ints;
}
 
 
//-------------------------------------------------------------------
 
 
vector<uint64_t> *cMsgMessage::getUint64Vector(const string &name) const {
  int len;
  const uint64_t *vals;
  int err = cMsgGetUint64Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put array values into a vector
  vector<uint64_t> *ints = new vector<uint64_t>;
  for (int i=0; i<len; i++) ints->push_back(vals[i]);
  return ints;
}
 
 
 
//-------------------------------------------------------------------
 
 
uint64_t *cMsgMessage::getUint64Array(const string &name) const {
  int len;
  const uint64_t *vals;
  int err = cMsgGetUint64Array(myMsgPointer, name.c_str(), &vals, &len);
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT) throw(cMsgException("Wrong field type")); 
    else throw(cMsgException(string("No payload item named ") + name));
  }
  // put values into new array 
  uint64_t *ints = new uint64_t[len];
  for (int i=0; i<len; i++) ints[i]=vals[i];
  return ints;
}
 
 
//-------------------------------------------------------------------
// ADD METHODS
//-------------------------------------------------------------------
 
//-------------------------------------------------------------------
// BINARY
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const char *src, int size, int endian) {
  int err = cMsgAddBinary(myMsgPointer, name.c_str(), src, size, endian);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT)     throw(cMsgException("Improper name or if error in binary-to-text conversion"));
    else if (err == CMSG_BAD_ARGUMENT)   throw(cMsgException("src or name null, size < 1, or endian improper value")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
void cMsgMessage::add(const string &name, const char **srcs, int number,
                      const int sizes[], const int endians[]) {
    int err = cMsgAddBinaryArray(myMsgPointer, name.c_str(), srcs, number, sizes, endians);
    if (err != CMSG_OK) {
        if (err == CMSG_BAD_FORMAT) throw(cMsgException("Improper name or if error in binary-to-text conversion"));
        else if (err == CMSG_BAD_ARGUMENT)   throw(cMsgException("srcs or name null, sizes < 1, or endians improper value"));
        else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
        else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available"));
        else throw(cMsgException("Error"));
    }
}
 
 
 
//-------------------------------------------------------------------
// CMSG STRINGS
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const string &s) {
    int err = cMsgAddString(myMsgPointer, name.c_str(), s.c_str());
    if (err != CMSG_OK) {
             if (err == CMSG_BAD_FORMAT)     throw(cMsgException("Improper name"));
        else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
        else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available"));
        else throw(cMsgException("Error"));
    }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const string *s) {
  add(name,*s);
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const char **strs, int len) {
    if (strs == NULL) throw (cMsgException("strs arg is null"));
    if (len < 1) throw (cMsgException("string array len < 1"));
 
    int err = cMsgAddStringArray(myMsgPointer, name.c_str(), strs, len);
    if (err != CMSG_OK) {
             if (err == CMSG_BAD_FORMAT)     throw(cMsgException("Improper name"));
        else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
        else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available"));
        else throw(cMsgException("Error"));
    }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const string *strs, int len) {
  if (strs == NULL) throw (cMsgException("strs arg is null"));
  if (len < 1) throw (cMsgException("string array len < 1"));
 
#ifdef linux
  const char *strings[len];
#else
  const char **strings = (const char **)malloc(len*sizeof(char *));
  if (strings == NULL) throw(cMsgException("No memory available"));
#endif
  
  for (int i=0; i<len; i++) {
    strings[i] = strs[i].c_str();
  }
 
  int err = cMsgAddStringArray(myMsgPointer, name.c_str(), strings, len);
#ifndef linux
  free(strings);
#endif
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT)     throw(cMsgException("Improper name"));
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available"));
    else throw(cMsgException("Error"));
  }
 
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<string> &strs) {
    if (strs.size() < 1) throw(cMsgException("Zero length vector"));
#ifdef linux
    const char *strings[strs.size()];
#else
    const char **strings = (const char **)malloc(strs.size()*sizeof(char *));
    if (strings == NULL) throw(cMsgException("No memory available"));
#endif
 
  for (vector<string>::size_type i=0; i < strs.size(); i++) {
    strings[i] = strs[i].c_str();
  }
 
  int err = cMsgAddStringArray(myMsgPointer, name.c_str(), strings, strs.size());
#ifndef linux
  free(strings);
#endif
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT)     throw(cMsgException("Improper name"));
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available"));
    else throw(cMsgException("Error"));
  }
}
 
void cMsgMessage::add(const string &name, const vector<string> *strs) {
  add(name,*strs);
}
 
//-------------------------------------------------------------------
// CMSG MESSAGES
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const cMsgMessage &msg) {
    int err = cMsgAddMessage(myMsgPointer, name.c_str(), msg.myMsgPointer);
    if (err != CMSG_OK) {
        if (err == CMSG_BAD_FORMAT)          throw(cMsgException("Improper name"));
        else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
        else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available"));
        else throw(cMsgException("Error"));
    }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const cMsgMessage *msg) {
  add(name,*msg);
}
 
//-------------------------------------------------------------------
 
 
void cMsgMessage::add(const string &name, const cMsgMessage *msg, int len) {
  if (msg == NULL) throw (cMsgException("msg arg is null"));
  if (len < 1) throw (cMsgException("cmsg message array len < 1"));
  
#ifdef linux
  const void *msgs[len];
#else
  const void **msgs = (const void **)malloc(len*sizeof(void *));
  if (msgs == NULL) throw(cMsgException("No memory available"));
#endif
 
  for (int i=0; i<len; i++) {
    msgs[i] = msg[i].myMsgPointer;
  }
 
  int err = cMsgAddMessageArray(myMsgPointer, name.c_str(), msgs, len);
#ifndef linux
  free(msgs);
#endif
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT)          throw(cMsgException("Improper name"));
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
  
}
 
 
//-------------------------------------------------------------------
 
 
void cMsgMessage::add(const string &name, const cMsgMessage* *msg, int len) {
  if (msg == NULL) throw (cMsgException("msg arg is null"));
  if (len < 1) throw (cMsgException("cmsg message array len < 1"));
  
#ifdef linux
  const void *msgs[len];
#else
  const void **msgs = (const void **)malloc(len*sizeof(void *));
  if (msgs == NULL) throw(cMsgException("No memory available"));
#endif
 
  for (int i=0; i<len; i++) {
    msgs[i] = msg[i]->myMsgPointer;
  }
 
  int err = cMsgAddMessageArray(myMsgPointer, name.c_str(), msgs, len);
#ifndef linux
  free(msgs);
#endif
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT)          throw(cMsgException("Improper name"));
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
  
}
 
 
//-------------------------------------------------------------------
 
 
void cMsgMessage::add(const string &name, const vector<cMsgMessage*> &msgPVec) {
    if (msgPVec.size() < 1) throw(cMsgException("Zero length vector"));
#ifdef linux
    const void *msgs[msgPVec.size()];
#else
    const void **msgs = (const void **)malloc(msgPVec.size()*sizeof(void *));
    if (msgs == NULL) throw(cMsgException("No memory available"));
#endif
  
  for (vector<cMsgMessage*>::size_type i=0; i < msgPVec.size(); i++) {
    msgs[i] = msgPVec[i]->myMsgPointer;
  }
  
  int err = cMsgAddMessageArray(myMsgPointer, name.c_str(), msgs, msgPVec.size());
#ifndef linux
  free(msgs);
#endif
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT)          throw(cMsgException("Improper name"));
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
  
}
 
 
//-------------------------------------------------------------------
 
 
void cMsgMessage::add(const string &name, const vector<cMsgMessage> &msgVec) {
    if (msgVec.size() < 1) throw(cMsgException("Zero length vector"));
#ifdef linux
    const void *msgs[msgVec.size()];
#else
    const void **msgs = (const void **)malloc(msgVec.size()*sizeof(void *));
    if (msgs == NULL) throw(cMsgException("No memory available"));
#endif
  
  for (vector<cMsgMessage>::size_type i=0; i < msgVec.size(); i++) {
    msgs[i] = msgVec[i].myMsgPointer;
  }
  
  int err = cMsgAddMessageArray(myMsgPointer, name.c_str(), msgs, msgVec.size());
#ifndef linux
  free(msgs);
#endif
  if (err != CMSG_OK) {
    if (err == CMSG_BAD_FORMAT)          throw(cMsgException("Improper name"));
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used"));
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
  
}
 
 
//-------------------------------------------------------------------
 
 
void cMsgMessage::add(const string &name, const vector<cMsgMessage*> *msgPVec) {
  add(name,*msgPVec);
}
 
 
//-------------------------------------------------------------------
 
 
void cMsgMessage::add(const string &name, const vector<cMsgMessage> *msgVec) {
  add(name,*msgVec);
}
 
 
//-------------------------------------------------------------------
// REALS
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, float val) {
  int err = cMsgAddFloat(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, double val) {
  int err = cMsgAddDouble(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
// REAL ARRAYS
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const float *vals, int len) {
  int err = cMsgAddFloatArray(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null"));
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<float> &vals) {
  int err = cMsgAddFloatArray(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<float> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const double *vals, int len) {
  int err = cMsgAddDoubleArray(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<double> &vals) {
  int err = cMsgAddDoubleArray(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<double> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
// INTS
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, int8_t val) {
  int err = cMsgAddInt8(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, int16_t val) {
  int err = cMsgAddInt16(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, int32_t val) {
  int err = cMsgAddInt32(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, int64_t val) {
  int err = cMsgAddInt64(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, uint8_t val) {
  int err = cMsgAddUint8(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, uint16_t val) {
  int err = cMsgAddUint16(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, uint32_t val) {
  int err = cMsgAddUint32(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, uint64_t val) {
  int err = cMsgAddUint64(myMsgPointer, name.c_str(), val);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
// INT ARRAYS
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const int8_t *vals, int len) {
  int err = cMsgAddInt8Array(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<int8_t> &vals) {
  
  // Can transform vector into array since STL standard mandates continguous
  // memory for storage of vector data (ie it's a standard C++ technique).
  int err = cMsgAddInt8Array(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<int8_t> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const int16_t *vals, int len) {
  int err = cMsgAddInt16Array(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<int16_t> &vals) {
  // Can transform vector into array since STL standard mandates continguous
  // memory for storage of vector data (ie it's a standard C++ technique).
  int err = cMsgAddInt16Array(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<int16_t> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const int32_t *vals, int len) {
  int err = cMsgAddInt32Array(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<int32_t> &vals) {
  
  // Can transform vector into array since STL standard mandates continguous
  // memory for storage of vector data (ie it's a standard C++ technique).
  int err = cMsgAddInt32Array(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<int32_t> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const int64_t *vals, int len) {
  int err = cMsgAddInt64Array(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<int64_t> &vals) {
  
  // Can transform vector into array since STL standard mandates continguous
  // memory for storage of vector data (ie it's a standard C++ technique).
  int err = cMsgAddInt64Array(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<int64_t> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const uint8_t *vals, int len) {
  int err = cMsgAddUint8Array(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<uint8_t> &vals) {
  
  // Can transform vector into array since STL standard mandates continguous
  // memory for storage of vector data (ie it's a standard C++ technique).
  int err = cMsgAddUint8Array(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<uint8_t> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const uint16_t *vals, int len) {
  int err = cMsgAddUint16Array(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<uint16_t> &vals) {
  
  // Can transform vector into array since STL standard mandates continguous
  // memory for storage of vector data (ie it's a standard C++ technique).
  int err = cMsgAddUint16Array(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<uint16_t> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const uint32_t *vals, int len) {
  int err = cMsgAddUint32Array(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<uint32_t> &vals) {
  
  // Can transform vector into array since STL standard mandates continguous
  // memory for storage of vector data (ie it's a standard C++ technique).
  int err = cMsgAddUint32Array(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<uint32_t> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const uint64_t *vals, int len) {
  int err = cMsgAddUint64Array(myMsgPointer, name.c_str(), vals, len);
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name or vals is null")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<uint64_t> &vals) {
  
  // Can transform vector into array since STL standard mandates continguous
  // memory for storage of vector data (ie it's a standard C++ technique).
  int err = cMsgAddUint64Array(myMsgPointer, name.c_str(), &vals[0], vals.size());
  if (err != CMSG_OK) {
         if (err == CMSG_BAD_FORMAT ||
             err == CMSG_BAD_ARGUMENT)   throw(cMsgException("Improper name")); 
    else if (err == CMSG_ALREADY_EXISTS) throw(cMsgException("Name being used")); 
    else if (err == CMSG_OUT_OF_MEMORY)  throw(cMsgException("No memory available")); 
    else throw(cMsgException("Error")); 
  }
}
 
//-------------------------------------------------------------------
 
void cMsgMessage::add(const string &name, const vector<uint64_t> *vals) {
  add(name,*vals);
}
 
//-------------------------------------------------------------------
 
 
} // namespace cmsg