gear_packet_m.cc

基于Oment++的无线传感器网络仿真

//
// Generated file, do not edit! Created by opp_msgc.
//

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

#include "Gear_packet_m.h"

class locationDescriptor : public cStructDescriptor
{
  public:
    locationDescriptor(void *p=NULL);
    virtual ~locationDescriptor();
    locationDescriptor& operator=(const locationDescriptor& other);
    virtual cObject *dup() const {return new locationDescriptor(*this);}

    virtual int getFieldCount();
    virtual const char *getFieldName(int field);
    virtual int getFieldType(int field);
    virtual const char *getFieldTypeString(int field);
    virtual const char *getFieldEnumName(int field);
    virtual int getArraySize(int field);

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

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

Register_Class(locationDescriptor);

locationDescriptor::locationDescriptor(void *p) : cStructDescriptor(p)
{
}

locationDescriptor::~locationDescriptor()
{
}

int locationDescriptor::getFieldCount()
{
    return 2;
}

int locationDescriptor::getFieldType(int field)
{
    switch (field) {
        case 0: return FT_BASIC;
        case 1: return FT_BASIC;
        default: return FT_INVALID;
    }
}

const char *locationDescriptor::getFieldName(int field)
{
    switch (field) {
        case 0: return "x";
        case 1: return "y";
        default: return NULL;
    }
}

const char *locationDescriptor::getFieldTypeString(int field)
{
    switch (field) {
        case 0: return "int";
        case 1: return "int";
        default: return NULL;
    }
}

const char *locationDescriptor::getFieldEnumName(int field)
{
    switch (field) {
        default: return NULL;
    }
}

int locationDescriptor::getArraySize(int field)
{
    location *pp = (location *)p;
    switch (field) {
        default: return 0;
    }
}

bool locationDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    location *pp = (location *)p;
    switch (field) {
        case 0: long2string(pp->x,resultbuf,bufsize); return true;
        case 1: long2string(pp->y,resultbuf,bufsize); return true;
        default: return false;
    }
}

bool locationDescriptor::setFieldAsString(int field, int i, const char *value)
{
    location *pp = (location *)p;
    switch (field) {
        case 0: pp->x = string2long(value); return true;
        case 1: pp->y = string2long(value); return true;
        default: return false;
    }
}

const char *locationDescriptor::getFieldStructName(int field)
{
    switch (field) {
        default: return NULL;
    }
}

void *locationDescriptor::getFieldStructPointer(int field, int i)
{
    location *pp = (location *)p;
    switch (field) {
        default: return NULL;
    }
}

sFieldWrapper *locationDescriptor::getFieldWrapper(int field, int i)
{
    return NULL;
}

class HeaderDescriptor : public cStructDescriptor
{
  public:
    HeaderDescriptor(void *p=NULL);
    virtual ~HeaderDescriptor();
    HeaderDescriptor& operator=(const HeaderDescriptor& other);
    virtual cObject *dup() const {return new HeaderDescriptor(*this);}

    virtual int getFieldCount();
    virtual const char *getFieldName(int field);
    virtual int getFieldType(int field);
    virtual const char *getFieldTypeString(int field);
    virtual const char *getFieldEnumName(int field);
    virtual int getArraySize(int field);

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

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

Register_Class(HeaderDescriptor);

HeaderDescriptor::HeaderDescriptor(void *p) : cStructDescriptor(p)
{
}

HeaderDescriptor::~HeaderDescriptor()
{
}

int HeaderDescriptor::getFieldCount()
{
    return 7;
}

int HeaderDescriptor::getFieldType(int field)
{
    switch (field) {
        case 0: return FT_STRUCT;
        case 1: return FT_BASIC;
        case 2: return FT_BASIC;
        case 3: return FT_STRUCT;
        case 4: return FT_BASIC;
        case 5: return FT_BASIC_ARRAY;
        case 6: return FT_BASIC;
        default: return FT_INVALID;
    }
}

const char *HeaderDescriptor::getFieldName(int field)
{
    switch (field) {
        case 0: return "srcLoc";
        case 1: return "srcNodeId";
        case 2: return "ttl";
        case 3: return "destLoc";
        case 4: return "NextHopDestId";
        case 5: return "arr_vistNodeList";
        case 6: return "OriginSrc";
        default: return NULL;
    }
}

const char *HeaderDescriptor::getFieldTypeString(int field)
{
    switch (field) {
        case 0: return "location";
        case 1: return "unsigned int";
        case 2: return "unsigned short";
        case 3: return "location";
        case 4: return "unsigned int";
        case 5: return "int";
        case 6: return "int";
        default: return NULL;
    }
}

const char *HeaderDescriptor::getFieldEnumName(int field)
{
    switch (field) {
        default: return NULL;
    }
}

int HeaderDescriptor::getArraySize(int field)
{
    Header *pp = (Header *)p;
    switch (field) {
        case 5: return 50;
        default: return 0;
    }
}

bool HeaderDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    Header *pp = (Header *)p;
    switch (field) {
        case 0: return false;
        case 1: long2string(pp->srcNodeId,resultbuf,bufsize); return true;
        case 2: long2string(pp->ttl,resultbuf,bufsize); return true;
        case 3: return false;
        case 4: long2string(pp->NextHopDestId,resultbuf,bufsize); return true;
        case 5: if (i>=50) return false;
                long2string(pp->arr_vistNodeList[i],resultbuf,bufsize); return true;
        case 6: long2string(pp->OriginSrc,resultbuf,bufsize); return true;
        default: return false;
    }
}

bool HeaderDescriptor::setFieldAsString(int field, int i, const char *value)
{
    Header *pp = (Header *)p;
    switch (field) {
        case 0: return false;
        case 1: pp->srcNodeId = string2long(value); return true;
        case 2: pp->ttl = string2long(value); return true;
        case 3: return false;
        case 4: pp->NextHopDestId = string2long(value); return true;
        case 5: if (i>=50) return false;
                pp->arr_vistNodeList[i] = string2long(value); return true;
        case 6: pp->OriginSrc = string2long(value); return true;
        default: return false;
    }
}

const char *HeaderDescriptor::getFieldStructName(int field)
{
    switch (field) {
        case 0: return "location"; break;
        case 3: return "location"; break;
        default: return NULL;
    }
}

void *HeaderDescriptor::getFieldStructPointer(int field, int i)
{
    Header *pp = (Header *)p;
    switch (field) {
        case 0: return (void *)&pp->srcLoc; break;
        case 3: return (void *)&pp->destLoc; break;
        default: return NULL;
    }
}

sFieldWrapper *HeaderDescriptor::getFieldWrapper(int field, int i)
{
    return NULL;
}

Register_Class(BeaconPkt);

BeaconPkt::BeaconPkt(const char *name, int kind) : cMessage(name,kind)
{
    unsigned int i;
}

BeaconPkt::BeaconPkt(const BeaconPkt& other) : cMessage()
{
    unsigned int i;
    setName(other.name());
    operator=(other);
}

BeaconPkt::~BeaconPkt()
{
}

BeaconPkt& BeaconPkt::operator=(const BeaconPkt& other)
{
    if (this==&other) return *this;
    unsigned int i;
    cMessage::operator=(other);
    this->hdr = other.hdr;
    return *this;
}

Header& BeaconPkt::getHdr()
{
    return hdr;
}

void BeaconPkt::setHdr(const Header& hdr)
{
    this->hdr = hdr;
}

class BeaconPktDescriptor : public cStructDescriptor
{
  public:
    BeaconPktDescriptor(void *p=NULL);
    virtual ~BeaconPktDescriptor();
    BeaconPktDescriptor& operator=(const BeaconPktDescriptor& other);
    virtual cObject *dup() const {return new BeaconPktDescriptor(*this);}

    virtual int getFieldCount();
    virtual const char *getFieldName(int field);
    virtual int getFieldType(int field);
    virtual const char *getFieldTypeString(int field);
    virtual const char *getFieldEnumName(int field);
    virtual int getArraySize(int field);

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

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

Register_Class(BeaconPktDescriptor);

BeaconPktDescriptor::BeaconPktDescriptor(void *p) : cStructDescriptor(p)
{
}

BeaconPktDescriptor::~BeaconPktDescriptor()
{
}

int BeaconPktDescriptor::getFieldCount()
{
    return 1;
}

int BeaconPktDescriptor::getFieldType(int field)
{
    switch (field) {
        case 0: return FT_STRUCT;
        default: return FT_INVALID;
    }
}

const char *BeaconPktDescriptor::getFieldName(int field)
{
    switch (field) {
        case 0: return "hdr";
        default: return NULL;
    }
}

const char *BeaconPktDescriptor::getFieldTypeString(int field)
{
    switch (field) {
        case 0: return "Header";
        default: return NULL;
    }
}

const char *BeaconPktDescriptor::getFieldEnumName(int field)
{
    switch (field) {
        default: return NULL;
    }
}

int BeaconPktDescriptor::getArraySize(int field)
{
    BeaconPkt *pp = (BeaconPkt *)p;
    switch (field) {
        default: return 0;
    }
}

bool BeaconPktDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    BeaconPkt *pp = (BeaconPkt *)p;
    switch (field) {
        case 0: return false;
        default: return false;
    }
}

bool BeaconPktDescriptor::setFieldAsString(int field, int i, const char *value)
{
    BeaconPkt *pp = (BeaconPkt *)p;
    switch (field) {
        case 0: return false;
        default: return false;
    }
}

const char *BeaconPktDescriptor::getFieldStructName(int field)
{
    switch (field) {
        case 0: return "Header"; break;
        default: return NULL;
    }
}

void *BeaconPktDescriptor::getFieldStructPointer(int field, int i)
{
    BeaconPkt *pp = (BeaconPkt *)p;
    switch (field) {
        case 0: return (void *)&pp->getHdr(); break;
        default: return NULL;
    }
}

sFieldWrapper *BeaconPktDescriptor::getFieldWrapper(int field, int i)
{
    return NULL;
}

Register_Class(BeaconReplyPkt);

BeaconReplyPkt::BeaconReplyPkt(const char *name, int kind) : cMessage(name,kind)
{
    unsigned int i;
    this->energy = 0;
}

BeaconReplyPkt::BeaconReplyPkt(const BeaconReplyPkt& other) : cMessage()
{
    unsigned int i;
    setName(other.name());
    operator=(other);
}

BeaconReplyPkt::~BeaconReplyPkt()
{
}

BeaconReplyPkt& BeaconReplyPkt::operator=(const BeaconReplyPkt& other)
{
    if (this==&other) return *this;
    unsigned int i;
    cMessage::operator=(other);
    this->hdr = other.hdr;
    this->energy = other.energy;
    return *this;
}

Header& BeaconReplyPkt::getHdr()
{
    return hdr;
}

void BeaconReplyPkt::setHdr(const Header& hdr)
{
    this->hdr = hdr;
}

double BeaconReplyPkt::getEnergy() const
{
    return energy;
}

void BeaconReplyPkt::setEnergy(double energy)
{
    this->energy = energy;
}

class BeaconReplyPktDescriptor : public cStructDescriptor
{
  public:
    BeaconReplyPktDescriptor(void *p=NULL);
    virtual ~BeaconReplyPktDescriptor();
    BeaconReplyPktDescriptor& operator=(const BeaconReplyPktDescriptor& other);
    virtual cObject *dup() const {return new BeaconReplyPktDescriptor(*this);}

    virtual int getFieldCount();
    virtual const char *getFieldName(int field);
    virtual int getFieldType(int field);
    virtual const char *getFieldTypeString(int field);
    virtual const char *getFieldEnumName(int field);
    virtual int getArraySize(int field);

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

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

Register_Class(BeaconReplyPktDescriptor);