phy_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 "Phy_Packet_m.h"

class sPhy_HeaderDescriptor : public cStructDescriptor
{
  public:
    sPhy_HeaderDescriptor(void *p=NULL);
    virtual ~sPhy_HeaderDescriptor();
    sPhy_HeaderDescriptor& operator=(const sPhy_HeaderDescriptor& other);
    virtual cObject *dup() const {return new sPhy_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(sPhy_HeaderDescriptor);

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

sPhy_HeaderDescriptor::~sPhy_HeaderDescriptor()
{
}

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

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

const char *sPhy_HeaderDescriptor::getFieldName(int field)
{
    switch (field) {
        case 0: return "SourceNodeAddress";
        case 1: return "DestinationNodeAddress";
        default: return NULL;
    }
}

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

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

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

bool sPhy_HeaderDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    sPhy_Header *pp = (sPhy_Header *)p;
    switch (field) {
        case 0: long2string(pp->SourceNodeAddress,resultbuf,bufsize); return true;
        case 1: long2string(pp->DestinationNodeAddress,resultbuf,bufsize); return true;
        default: return false;
    }
}

bool sPhy_HeaderDescriptor::setFieldAsString(int field, int i, const char *value)
{
    sPhy_Header *pp = (sPhy_Header *)p;
    switch (field) {
        case 0: pp->SourceNodeAddress = string2long(value); return true;
        case 1: pp->DestinationNodeAddress = string2long(value); return true;
        default: return false;
    }
}

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

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

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

Register_Class(cPhy_Packet);

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

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

cPhy_Packet::~cPhy_Packet()
{
}

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

sPhy_Header& cPhy_Packet::getHdr()
{
    return hdr;
}

void cPhy_Packet::setHdr(const sPhy_Header& hdr)
{
    this->hdr = hdr;
}

class cPhy_PacketDescriptor : public cStructDescriptor
{
  public:
    cPhy_PacketDescriptor(void *p=NULL);
    virtual ~cPhy_PacketDescriptor();
    cPhy_PacketDescriptor& operator=(const cPhy_PacketDescriptor& other);
    virtual cObject *dup() const {return new cPhy_PacketDescriptor(*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(cPhy_PacketDescriptor);

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

cPhy_PacketDescriptor::~cPhy_PacketDescriptor()
{
}

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

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

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

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

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

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

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

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

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

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

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