source: source/ariba/communication/modules/transport/omnet/AribaOmnetMessage_m.cc@ 2850

//
// Generated file, do not edit! Created by opp_msgc 3.4 from ./AribaOmnetMessage.msg.
//

// Disable warnings about unused variables, empty switch stmts, etc:
#ifdef _MSC_VER
#  pragma warning(disable:4101)
#  pragma warning(disable:4065)
#endif

#include <iostream>
#include <sstream>
#include "./AribaOmnetMessage_m.h"

// Template rule which fires if a struct or class doesn't have operator<<
template<typename T>
std::ostream& operator<<(std::ostream& out,const T&) {return out;}

// Another default rule (prevents compiler from choosing base class' doPacking())
template<typename T>
void doPacking(cCommBuffer *, T& t) {
    throw new cRuntimeError("Parsim error: no doPacking() function for type %s or its base class (check .msg and _m.cc/h files!)",opp_typename(typeid(t)));
}
template<typename T>
void doUnpacking(cCommBuffer *, T& t) {
    throw new cRuntimeError("Parsim error: no doUnpacking() function for type %s or its base class (check .msg and _m.cc/h files!)",opp_typename(typeid(t)));
}

// Automatically supply array (un)packing functions
template<typename T>
void doPacking(cCommBuffer *b, T *t, int n) {
    for (int i=0; i<n; i++)
        doPacking(b,t[i]);
}
template<typename T>
void doUnpacking(cCommBuffer *b, T *t, int n) {
    for (int i=0; i<n; i++)
        doUnpacking(b,t[i]);
}
inline void doPacking(cCommBuffer *, cPolymorphic&) {}
inline void doUnpacking(cCommBuffer *, cPolymorphic&) {}

#define DOPACKING(T,R) \
    inline void doPacking(cCommBuffer *b, T R a) {b->pack(a);}  \
    inline void doPacking(cCommBuffer *b, T *a, int n) {b->pack(a,n);}  \
    inline void doUnpacking(cCommBuffer *b, T& a) {b->unpack(a);}  \
    inline void doUnpacking(cCommBuffer *b, T *a, int n) {b->unpack(a,n);}
#define _
DOPACKING(char,_)
DOPACKING(unsigned char,_)
DOPACKING(bool,_)
DOPACKING(short,_)
DOPACKING(unsigned short,_)
DOPACKING(int,_)
DOPACKING(unsigned int,_)
DOPACKING(long,_)
DOPACKING(unsigned long,_)
DOPACKING(float,_)
DOPACKING(double,_)
DOPACKING(long double,_)
DOPACKING(char *,_)
DOPACKING(const char *,_)
DOPACKING(opp_string,&)
//DOPACKING(std::string,&)
#undef _
#undef DOPACKING


Register_Class(AribaOmnetMessage);

AribaOmnetMessage::AribaOmnetMessage(const char *name, int kind) : cMessage(name,kind)
{
    unsigned int i;
    this->port_var = 0;
    data_arraysize = 0;
    this->data_var = 0;
}

AribaOmnetMessage::AribaOmnetMessage(const AribaOmnetMessage& other) : cMessage()
{
    unsigned int i;
    setName(other.name());
    data_arraysize = 0;
    this->data_var = 0;
    operator=(other);
}

AribaOmnetMessage::~AribaOmnetMessage()
{
    unsigned int i;
    delete [] data_var;
}

AribaOmnetMessage& AribaOmnetMessage::operator=(const AribaOmnetMessage& other)
{
    if (this==&other) return *this;
    unsigned int i;
    cMessage::operator=(other);
    this->port_var = other.port_var;
    delete [] this->data_var;
    this->data_var = (other.data_arraysize==0) ? NULL : new unsigned char[other.data_arraysize];
    data_arraysize = other.data_arraysize;
    for (i=0; i<data_arraysize; i++)
        this->data_var[i] = other.data_var[i];
    return *this;
}

void AribaOmnetMessage::netPack(cCommBuffer *b)
{
    cMessage::netPack(b);
    doPacking(b,this->port_var);
    b->pack(data_arraysize);
    doPacking(b,this->data_var,data_arraysize);
}

void AribaOmnetMessage::netUnpack(cCommBuffer *b)
{
    cMessage::netUnpack(b);
    doUnpacking(b,this->port_var);
    delete [] this->data_var;
    b->unpack(data_arraysize);
    if (data_arraysize==0) {
        this->data_var = 0;
    } else {
        this->data_var = new unsigned char[data_arraysize];
        doUnpacking(b,this->data_var,data_arraysize);
    }
}

unsigned int AribaOmnetMessage::getPort() const
{
    return port_var;
}

void AribaOmnetMessage::setPort(unsigned int port_var)
{
    this->port_var = port_var;
}

void AribaOmnetMessage::setDataArraySize(unsigned int size)
{
    unsigned char *data_var2 = (size==0) ? NULL : new unsigned char[size];
    unsigned int sz = data_arraysize < size ? data_arraysize : size;
    unsigned int i;
    for (i=0; i<sz; i++)
        data_var2[i] = this->data_var[i];
    for (i=sz; i<size; i++)
        data_var2[i] = 0;
    data_arraysize = size;
    delete [] this->data_var;
    this->data_var = data_var2;
}

unsigned int AribaOmnetMessage::getDataArraySize() const
{
    return data_arraysize;
}

unsigned char AribaOmnetMessage::getData(unsigned int k) const
{
    if (k>=data_arraysize) throw new cRuntimeError("Array of size %d indexed by %d", data_arraysize, k);
    return data_var[k];
}

void AribaOmnetMessage::setData(unsigned int k, unsigned char data_var)
{
    if (k>=data_arraysize) throw new cRuntimeError("Array of size %d indexed by %d", data_arraysize, k);
    this->data_var[k]=data_var;
}

class AribaOmnetMessageDescriptor : public cClassDescriptor
{
  public:
    AribaOmnetMessageDescriptor();
    virtual ~AribaOmnetMessageDescriptor();

    virtual bool doesSupport(cPolymorphic *obj);
    virtual const char *getProperty(const char *propertyname);
    virtual int getFieldCount(void *object);
    virtual const char *getFieldName(void *object, int field);
    virtual unsigned int getFieldTypeFlags(void *object, int field);
    virtual const char *getFieldTypeString(void *object, int field);
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname);
    virtual int getArraySize(void *object, int field);

    virtual bool getFieldAsString(void *object, int field, int i, char *resultbuf, int bufsize);
    virtual bool setFieldAsString(void *object, int field, int i, const char *value);

    virtual const char *getFieldStructName(void *object, int field);
    virtual void *getFieldStructPointer(void *object, int field, int i);
};

Register_ClassDescriptor(AribaOmnetMessageDescriptor);

AribaOmnetMessageDescriptor::AribaOmnetMessageDescriptor() : cClassDescriptor("AribaOmnetMessage", "cMessage")
{
}

AribaOmnetMessageDescriptor::~AribaOmnetMessageDescriptor()
{
}

bool AribaOmnetMessageDescriptor::doesSupport(cPolymorphic *obj)
{
    return dynamic_cast<AribaOmnetMessage *>(obj)!=NULL;
}

const char *AribaOmnetMessageDescriptor::getProperty(const char *propertyname)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

int AribaOmnetMessageDescriptor::getFieldCount(void *object)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 2+basedesc->getFieldCount(object) : 2;
}

unsigned int AribaOmnetMessageDescriptor::getFieldTypeFlags(void *object, int field)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeFlags(object, field);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        case 0: return FD_ISEDITABLE;
        case 1: return FD_ISARRAY | FD_ISEDITABLE;
        default: return 0;
    }
}

const char *AribaOmnetMessageDescriptor::getFieldName(void *object, int field)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        case 0: return "port";
        case 1: return "data";
        default: return NULL;
    }
}

const char *AribaOmnetMessageDescriptor::getFieldTypeString(void *object, int field)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        case 0: return "unsigned int";
        case 1: return "unsigned char";
        default: return NULL;
    }
}

const char *AribaOmnetMessageDescriptor::getFieldProperty(void *object, int field, const char *propertyname)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int AribaOmnetMessageDescriptor::getArraySize(void *object, int field)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    AribaOmnetMessage *pp _MAYBEUNUSED = (AribaOmnetMessage *)object;
    switch (field) {
        case 1: return pp->getDataArraySize();
        default: return 0;
    }
}

bool AribaOmnetMessageDescriptor::getFieldAsString(void *object, int field, int i, char *resultbuf, int bufsize)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i,resultbuf,bufsize);
        field -= basedesc->getFieldCount(object);
    }
    AribaOmnetMessage *pp _MAYBEUNUSED = (AribaOmnetMessage *)object;
    switch (field) {
        case 0: long2string(pp->getPort(),resultbuf,bufsize); return true;
        case 1: long2string(pp->getData(i),resultbuf,bufsize); return true;
        default: return false;
    }
}

bool AribaOmnetMessageDescriptor::setFieldAsString(void *object, int field, int i, const char *value)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    AribaOmnetMessage *pp _MAYBEUNUSED = (AribaOmnetMessage *)object;
    switch (field) {
        case 0: pp->setPort(string2long(value)); return true;
        case 1: pp->setData(i,string2long(value)); return true;
        default: return false;
    }
}

const char *AribaOmnetMessageDescriptor::getFieldStructName(void *object, int field)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

void *AribaOmnetMessageDescriptor::getFieldStructPointer(void *object, int field, int i)
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    AribaOmnetMessage *pp _MAYBEUNUSED = (AribaOmnetMessage *)object;
    switch (field) {
        default: return NULL;
    }
}