gear_packet_m.cc

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

        default: return 0;
    }
}

bool ExpDataMsgDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    ExpDataMsg *pp = (ExpDataMsg *)p;
    switch (field) {
        case 0: return false;
        case 1: long2string(pp->getIQuerySrcId(),resultbuf,bufsize); return true;
        case 2: long2string(pp->getIExpDataSrcId(),resultbuf,bufsize); return true;
        default: return false;
    }
}

bool ExpDataMsgDescriptor::setFieldAsString(int field, int i, const char *value)
{
    ExpDataMsg *pp = (ExpDataMsg *)p;
    switch (field) {
        case 0: return false;
        case 1: pp->setIQuerySrcId(string2long(value)); return true;
        case 2: pp->setIExpDataSrcId(string2long(value)); return true;
        default: return false;
    }
}

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

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

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

Register_Class(GearPacket);

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

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

GearPacket::~GearPacket()
{
}

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

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

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

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

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

GearPacketDescriptor::~GearPacketDescriptor()
{
}

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

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

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

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

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

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

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

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

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

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

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

Register_Class(DataMsg);

DataMsg::DataMsg(const char *name, int kind) : cMessage(name,kind)
{
    unsigned int i;
    this->RegionX = 0;
    this->RegionY = 0;
    this->Radius = 0;
    this->Exploratory = false;
    this->iFinalDest = 0;
    this->Duration = 0;
    this->Rate = 0;
    this->LastEnforcedTime = 0;
    this->TimeDataFirstSent = 0;
}

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

DataMsg::~DataMsg()
{
}

DataMsg& DataMsg::operator=(const DataMsg& 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->Exploratory = other.Exploratory;
    this->iFinalDest = other.iFinalDest;
    this->Duration = other.Duration;
    this->Rate = other.Rate;
    this->LastEnforcedTime = other.LastEnforcedTime;
    this->TimeDataFirstSent = other.TimeDataFirstSent;
    return *this;
}

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

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

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

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

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

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

int DataMsg::getRadius() const
{
    return Radius;
}

void DataMsg::setRadius(int Radius)
{
    this->Radius = Radius;
}

bool DataMsg::getExploratory() const
{
    return Exploratory;
}

void DataMsg::setExploratory(bool Exploratory)
{
    this->Exploratory = Exploratory;
}

int DataMsg::getIFinalDest() const
{
    return iFinalDest;
}

void DataMsg::setIFinalDest(int iFinalDest)
{
    this->iFinalDest = iFinalDest;
}

double DataMsg::getDuration() const
{
    return Duration;
}

void DataMsg::setDuration(double Duration)
{
    this->Duration = Duration;
}

int DataMsg::getRate() const
{
    return Rate;
}

void DataMsg::setRate(int Rate)
{
    this->Rate = Rate;
}

double DataMsg::getLastEnforcedTime() const
{
    return LastEnforcedTime;
}

void DataMsg::setLastEnforcedTime(double LastEnforcedTime)
{
    this->LastEnforcedTime = LastEnforcedTime;
}

double DataMsg::getTimeDataFirstSent() const
{
    return TimeDataFirstSent;
}

void DataMsg::setTimeDataFirstSent(double TimeDataFirstSent)
{
    this->TimeDataFirstSent = TimeDataFirstSent;
}

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

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

DataMsgDescriptor::~DataMsgDescriptor()
{
}

int DataMsgDescriptor::getFieldCount()
{
    return 10;
}

int DataMsgDescriptor::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;
        case 8: return FT_BASIC;
        case 9: return FT_BASIC;
        default: return FT_INVALID;
    }
}

const char *DataMsgDescriptor::getFieldName(int field)
{
    switch (field) {
        case 0: return "hdr";
        case 1: return "RegionX";
        case 2: return "RegionY";
        case 3: return "Radius";
        case 4: return "Exploratory";
        case 5: return "iFinalDest";
        case 6: return "Duration";
        case 7: return "Rate";
        case 8: return "LastEnforcedTime";
        case 9: return "TimeDataFirstSent";
        default: return NULL;
    }
}

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

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

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

bool DataMsgDescriptor::getFieldAsString(int field, int i, char *resultbuf, int bufsize)
{
    DataMsg *pp = (DataMsg *)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: bool2string(pp->getExploratory(),resultbuf,bufsize); return true;
        case 5: long2string(pp->getIFinalDest(),resultbuf,bufsize); return true;
        case 6: double2string(pp->getDuration(),resultbuf,bufsize); return true;
        case 7: long2string(pp->getRate(),resultbuf,bufsize); return true;
        case 8: double2string(pp->getLastEnforcedTime(),resultbuf,bufsize); return true;
        case 9: double2string(pp->getTimeDataFirstSent(),resultbuf,bufsize); return true;
        default: return false;
    }
}

bool DataMsgDescriptor::setFieldAsString(int field, int i, const char *value)
{
    DataMsg *pp = (DataMsg *)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->setExploratory(string2bool(value)); return true;
        case 5: pp->setIFinalDest(string2long(value)); return true;
        case 6: pp->setDuration(string2double(value)); return true;
        case 7: pp->setRate(string2long(value)); return true;
        case 8: pp->setLastEnforcedTime(string2double(value)); return true;
        case 9: pp->setTimeDataFirstSent(string2double(value)); return true;
        default: return false;
    }
}

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

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

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