gear_packet_m.cc

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

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

BeaconReplyPktDescriptor::~BeaconReplyPktDescriptor()
{
}

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

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

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

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

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

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

bool BeaconReplyPktDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    BeaconReplyPkt *pp = (BeaconReplyPkt *)p;
    switch (field) {
        case 0: return false;
        case 1: double2string(pp->getEnergy(),resultbuf,bufsize); return true;
        default: return false;
    }
}

bool BeaconReplyPktDescriptor::setFieldAsString(int field, int i, const char *value)
{
    BeaconReplyPkt *pp = (BeaconReplyPkt *)p;
    switch (field) {
        case 0: return false;
        case 1: pp->setEnergy(string2double(value)); return true;
        default: return false;
    }
}

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

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

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

Register_Class(QueryPacket);

QueryPacket::QueryPacket(const char *name, int kind) : cMessage(name,kind)
{
    unsigned int i;
    this->RegionX = 0;
    this->RegionY = 0;
    this->radius = 0;
    this->iDuration = 0;
    this->iRate = 0;
    this->iQuerySrc = 0;
    this->exp = false;
}

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

QueryPacket::~QueryPacket()
{
}

QueryPacket& QueryPacket::operator=(const QueryPacket& other)
{
    if (this==&other) return *this;
    unsigned int i;
    cMessage::operator=(other);
    this->hdr = other.hdr;
    this->RegionX = other.RegionX;
    this->RegionY = other.RegionY;
    this->radius = other.radius;
    this->iDuration = other.iDuration;
    this->iRate = other.iRate;
    this->iQuerySrc = other.iQuerySrc;
    this->exp = other.exp;
    return *this;
}

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

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

int QueryPacket::getRegionX() const
{
    return RegionX;
}

void QueryPacket::setRegionX(int RegionX)
{
    this->RegionX = RegionX;
}

int QueryPacket::getRegionY() const
{
    return RegionY;
}

void QueryPacket::setRegionY(int RegionY)
{
    this->RegionY = RegionY;
}

int QueryPacket::getRadius() const
{
    return radius;
}

void QueryPacket::setRadius(int radius)
{
    this->radius = radius;
}

double QueryPacket::getIDuration() const
{
    return iDuration;
}

void QueryPacket::setIDuration(double iDuration)
{
    this->iDuration = iDuration;
}

int QueryPacket::getIRate() const
{
    return iRate;
}

void QueryPacket::setIRate(int iRate)
{
    this->iRate = iRate;
}

int QueryPacket::getIQuerySrc() const
{
    return iQuerySrc;
}

void QueryPacket::setIQuerySrc(int iQuerySrc)
{
    this->iQuerySrc = iQuerySrc;
}

bool QueryPacket::getExp() const
{
    return exp;
}

void QueryPacket::setExp(bool exp)
{
    this->exp = exp;
}

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

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

QueryPacketDescriptor::~QueryPacketDescriptor()
{
}

int QueryPacketDescriptor::getFieldCount()
{
    return 8;
}

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

const char *QueryPacketDescriptor::getFieldName(int field)
{
    switch (field) {
        case 0: return "hdr";
        case 1: return "RegionX";
        case 2: return "RegionY";
        case 3: return "radius";
        case 4: return "iDuration";
        case 5: return "iRate";
        case 6: return "iQuerySrc";
        case 7: return "exp";
        default: return NULL;
    }
}

const char *QueryPacketDescriptor::getFieldTypeString(int field)
{
    switch (field) {
        case 0: return "Header";
        case 1: return "int";
        case 2: return "int";
        case 3: return "int";
        case 4: return "double";
        case 5: return "int";
        case 6: return "int";
        case 7: return "bool";
        default: return NULL;
    }
}

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

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

bool QueryPacketDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    QueryPacket *pp = (QueryPacket *)p;
    switch (field) {
        case 0: return false;
        case 1: long2string(pp->getRegionX(),resultbuf,bufsize); return true;
        case 2: long2string(pp->getRegionY(),resultbuf,bufsize); return true;
        case 3: long2string(pp->getRadius(),resultbuf,bufsize); return true;
        case 4: double2string(pp->getIDuration(),resultbuf,bufsize); return true;
        case 5: long2string(pp->getIRate(),resultbuf,bufsize); return true;
        case 6: long2string(pp->getIQuerySrc(),resultbuf,bufsize); return true;
        case 7: bool2string(pp->getExp(),resultbuf,bufsize); return true;
        default: return false;
    }
}

bool QueryPacketDescriptor::setFieldAsString(int field, int i, const char *value)
{
    QueryPacket *pp = (QueryPacket *)p;
    switch (field) {
        case 0: return false;
        case 1: pp->setRegionX(string2long(value)); return true;
        case 2: pp->setRegionY(string2long(value)); return true;
        case 3: pp->setRadius(string2long(value)); return true;
        case 4: pp->setIDuration(string2double(value)); return true;
        case 5: pp->setIRate(string2long(value)); return true;
        case 6: pp->setIQuerySrc(string2long(value)); return true;
        case 7: pp->setExp(string2bool(value)); return true;
        default: return false;
    }
}

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

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

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

Register_Class(ExpDataMsg);

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

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

ExpDataMsg::~ExpDataMsg()
{
}

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

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

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

int ExpDataMsg::getIQuerySrcId() const
{
    return iQuerySrcId;
}

void ExpDataMsg::setIQuerySrcId(int iQuerySrcId)
{
    this->iQuerySrcId = iQuerySrcId;
}

int ExpDataMsg::getIExpDataSrcId() const
{
    return iExpDataSrcId;
}

void ExpDataMsg::setIExpDataSrcId(int iExpDataSrcId)
{
    this->iExpDataSrcId = iExpDataSrcId;
}

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

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

ExpDataMsgDescriptor::~ExpDataMsgDescriptor()
{
}

int ExpDataMsgDescriptor::getFieldCount()
{
    return 3;
}

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

const char *ExpDataMsgDescriptor::getFieldName(int field)
{
    switch (field) {
        case 0: return "hdr";
        case 1: return "iQuerySrcId";
        case 2: return "iExpDataSrcId";
        default: return NULL;
    }
}

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

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

int ExpDataMsgDescriptor::getArraySize(int field)
{
    ExpDataMsg *pp = (ExpDataMsg *)p;
    switch (field) {