PDU_m.cc

Go to the documentation of this file.

//
// Generated file, do not edit! Created by nedtool 5.0 from Common/PDU.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 "PDU_m.h"

namespace omnetpp {

// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument

// Packing/unpacking an std::vector
template<typename T, typename A>
void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
{
    int n = v.size();
    doParsimPacking(buffer, n);
    for (int i = 0; i < n; i++)
        doParsimPacking(buffer, v[i]);
}

template<typename T, typename A>
void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
{
    int n;
    doParsimUnpacking(buffer, n);
    v.resize(n);
    for (int i = 0; i < n; i++)
        doParsimUnpacking(buffer, v[i]);
}

// Packing/unpacking an std::list
template<typename T, typename A>
void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
{
    doParsimPacking(buffer, (int)l.size());
    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
        doParsimPacking(buffer, (T&)*it);
}

template<typename T, typename A>
void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
{
    int n;
    doParsimUnpacking(buffer, n);
    for (int i=0; i<n; i++) {
        l.push_back(T());
        doParsimUnpacking(buffer, l.back());
    }
}

// Packing/unpacking an std::set
template<typename T, typename Tr, typename A>
void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
{
    doParsimPacking(buffer, (int)s.size());
    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
        doParsimPacking(buffer, *it);
}

template<typename T, typename Tr, typename A>
void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
{
    int n;
    doParsimUnpacking(buffer, n);
    for (int i=0; i<n; i++) {
        T x;
        doParsimUnpacking(buffer, x);
        s.insert(x);
    }
}

// Packing/unpacking an std::map
template<typename K, typename V, typename Tr, typename A>
void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
{
    doParsimPacking(buffer, (int)m.size());
    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
        doParsimPacking(buffer, it->first);
        doParsimPacking(buffer, it->second);
    }
}

template<typename K, typename V, typename Tr, typename A>
void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
{
    int n;
    doParsimUnpacking(buffer, n);
    for (int i=0; i<n; i++) {
        K k; V v;
        doParsimUnpacking(buffer, k);
        doParsimUnpacking(buffer, v);
        m[k] = v;
    }
}

// Default pack/unpack function for arrays
template<typename T>
void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
{
    for (int i = 0; i < n; i++)
        doParsimPacking(b, t[i]);
}

template<typename T>
void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
{
    for (int i = 0; i < n; i++)
        doParsimUnpacking(b, t[i]);
}

// Default rule to prevent compiler from choosing base class' doParsimPacking() function
template<typename T>
void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
{
    throw omnetpp::cRuntimeError("Parsim error: no doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
}

template<typename T>
void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
{
    throw omnetpp::cRuntimeError("Parsim error: no doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
}

}  // namespace omnetpp


// forward
template<typename T, typename A>
std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);

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

// operator<< for std::vector<T>
template<typename T, typename A>
inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
{
    out.put('{');
    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
    {
        if (it != vec.begin()) {
            out.put(','); out.put(' ');
        }
        out << *it;
    }
    out.put('}');
    
    char buf[32];
    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
    out.write(buf, strlen(buf));
    return out;
}

EXECUTE_ON_STARTUP(
    omnetpp::cEnum *e = omnetpp::cEnum::find("PDUType");
    if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("PDUType"));
    e->insert(MANAGEMENT_PDU, "MANAGEMENT_PDU");
    e->insert(DATA_TRANSFER_PDU, "DATA_TRANSFER_PDU");
    e->insert(CONTROL_ACK_PDU, "CONTROL_ACK_PDU");
    e->insert(ACK_ONLY_PDU, "ACK_ONLY_PDU");
    e->insert(NACK_ONLY_PDU, "NACK_ONLY_PDU");
    e->insert(FLOW_ONLY_PDU, "FLOW_ONLY_PDU");
    e->insert(ACK_FLOW_PDU, "ACK_FLOW_PDU");
    e->insert(NACK_FLOW_PDU, "NACK_FLOW_PDU");
    e->insert(SELECT_ACK_PDU, "SELECT_ACK_PDU");
    e->insert(SELECT_NACK_PDU, "SELECT_NACK_PDU");
    e->insert(SELECT_ACK_FLOW_PDU, "SELECT_ACK_FLOW_PDU");
    e->insert(SELECT_NACK_FLOW_PDU, "SELECT_NACK_FLOW_PDU");
    e->insert(RENDEZVOUS_PDU, "RENDEZVOUS_PDU");
);

EXECUTE_ON_STARTUP(
    omnetpp::cEnum *e = omnetpp::cEnum::find("PDUTypeBits");
    if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("PDUTypeBits"));
    e->insert(PDU_ACK_BIT, "PDU_ACK_BIT");
    e->insert(PDU_NACK_BIT, "PDU_NACK_BIT");
    e->insert(PDU_FC_BIT, "PDU_FC_BIT");
    e->insert(PDU_SEL_BIT, "PDU_SEL_BIT");
);

EXECUTE_ON_STARTUP(
    omnetpp::cEnum *e = omnetpp::cEnum::find("FLAGS");
    if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("FLAGS"));
);

PDU_Base::PDU_Base(const char *name, int kind) : ::omnetpp::cPacket(name,kind)
{
    this->setByteLength(10);
    this->setSchedulingPriority(-1);

    this->version = 1;
    this->type = 0;
    this->flags = 0;
    this->pduLen = PDU_HEADER_LEN;
    this->seqNum = 0;
    this->hopCount = 255;
}

PDU_Base::PDU_Base(const PDU_Base& other) : ::omnetpp::cPacket(other)
{
    copy(other);
}

PDU_Base::~PDU_Base()
{
}

PDU_Base& PDU_Base::operator=(const PDU_Base& other)
{
    if (this==&other) return *this;
    ::omnetpp::cPacket::operator=(other);
    copy(other);
    return *this;
}

void PDU_Base::copy(const PDU_Base& other)
{
    this->displayString = other.displayString;
    this->version = other.version;
    this->srcAddr = other.srcAddr;
    this->dstAddr = other.dstAddr;
    this->srcApn = other.srcApn;
    this->dstApn = other.dstApn;
    this->connId = other.connId;
    this->type = other.type;
    this->flags = other.flags;
    this->pduLen = other.pduLen;
    this->seqNum = other.seqNum;
    this->hopCount = other.hopCount;
}

void PDU_Base::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::omnetpp::cPacket::parsimPack(b);
    doParsimPacking(b,this->displayString);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->srcAddr);
    doParsimPacking(b,this->dstAddr);
    doParsimPacking(b,this->srcApn);
    doParsimPacking(b,this->dstApn);
    doParsimPacking(b,this->connId);
    doParsimPacking(b,this->type);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->pduLen);
    doParsimPacking(b,this->seqNum);
    doParsimPacking(b,this->hopCount);
}

void PDU_Base::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::omnetpp::cPacket::parsimUnpack(b);
    doParsimUnpacking(b,this->displayString);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->srcAddr);
    doParsimUnpacking(b,this->dstAddr);
    doParsimUnpacking(b,this->srcApn);
    doParsimUnpacking(b,this->dstApn);
    doParsimUnpacking(b,this->connId);
    doParsimUnpacking(b,this->type);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->pduLen);
    doParsimUnpacking(b,this->seqNum);
    doParsimUnpacking(b,this->hopCount);
}

const char * PDU_Base::getDisplayString() const
{
    return this->displayString.c_str();
}

void PDU_Base::setDisplayString(const char * displayString)
{
    this->displayString = displayString;
}

unsigned int PDU_Base::getVersion() const
{
    return this->version;
}

void PDU_Base::setVersion(unsigned int version)
{
    this->version = version;
}

Address& PDU_Base::getSrcAddr()
{
    return this->srcAddr;
}

void PDU_Base::setSrcAddr(const Address& srcAddr)
{
    this->srcAddr = srcAddr;
}

Address& PDU_Base::getDstAddr()
{
    return this->dstAddr;
}

void PDU_Base::setDstAddr(const Address& dstAddr)
{
    this->dstAddr = dstAddr;
}

APN& PDU_Base::getSrcApn()
{
    return this->srcApn;
}

void PDU_Base::setSrcApn(const APN& srcApn)
{
    this->srcApn = srcApn;
}

APN& PDU_Base::getDstApn()
{
    return this->dstApn;
}

void PDU_Base::setDstApn(const APN& dstApn)
{
    this->dstApn = dstApn;
}

ConnectionId& PDU_Base::getConnId()
{
    return this->connId;
}

void PDU_Base::setConnId(const ConnectionId& connId)
{
    this->connId = connId;
}

int PDU_Base::getType() const
{
    return this->type;
}

void PDU_Base::setType(int type)
{
    this->type = type;
}

int PDU_Base::getFlags() const
{
    return this->flags;
}

void PDU_Base::setFlags(int flags)
{
    this->flags = flags;
}

unsigned int PDU_Base::getPduLen() const
{
    return this->pduLen;
}

void PDU_Base::setPduLen(unsigned int pduLen)
{
    this->pduLen = pduLen;
}

unsigned int PDU_Base::getSeqNum() const
{
    return this->seqNum;
}

void PDU_Base::setSeqNum(unsigned int seqNum)
{
    this->seqNum = seqNum;
}

unsigned int PDU_Base::getHopCount() const
{
    return this->hopCount;
}

void PDU_Base::setHopCount(unsigned int hopCount)
{
    this->hopCount = hopCount;
}

class PDUDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
  public:
    PDUDescriptor();
    virtual ~PDUDescriptor();

    virtual bool doesSupport(omnetpp::cObject *obj) const override;
    virtual const char **getPropertyNames() const override;
    virtual const char *getProperty(const char *propertyname) const override;
    virtual int getFieldCount() const override;
    virtual const char *getFieldName(int field) const override;
    virtual int findField(const char *fieldName) const override;
    virtual unsigned int getFieldTypeFlags(int field) const override;
    virtual const char *getFieldTypeString(int field) const override;
    virtual const char **getFieldPropertyNames(int field) const override;
    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
    virtual int getFieldArraySize(void *object, int field) const override;

    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;

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

Register_ClassDescriptor(PDUDescriptor);

PDUDescriptor::PDUDescriptor() : omnetpp::cClassDescriptor("PDU", "omnetpp::cPacket")
{
    propertynames = nullptr;
}

PDUDescriptor::~PDUDescriptor()
{
    delete[] propertynames;
}

bool PDUDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<PDU_Base *>(obj)!=nullptr;
}

const char **PDUDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "customize",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *PDUDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname,"customize")) return "true";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int PDUDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 12+basedesc->getFieldCount() : 12;
}

unsigned int PDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    static unsigned int fieldTypeFlags[] = {
        FD_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISCOMPOUND,
        FD_ISCOMPOUND,
        FD_ISCOMPOUND,
        FD_ISCOMPOUND,
        FD_ISCOMPOUND,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
    };
    return (field>=0 && field<12) ? fieldTypeFlags[field] : 0;
}

const char *PDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    static const char *fieldNames[] = {
        "displayString",
        "version",
        "srcAddr",
        "dstAddr",
        "srcApn",
        "dstApn",
        "connId",
        "type",
        "flags",
        "pduLen",
        "seqNum",
        "hopCount",
    };
    return (field>=0 && field<12) ? fieldNames[field] : nullptr;
}

int PDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='d' && strcmp(fieldName, "displayString")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcAddr")==0) return base+2;
    if (fieldName[0]=='d' && strcmp(fieldName, "dstAddr")==0) return base+3;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcApn")==0) return base+4;
    if (fieldName[0]=='d' && strcmp(fieldName, "dstApn")==0) return base+5;
    if (fieldName[0]=='c' && strcmp(fieldName, "connId")==0) return base+6;
    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+7;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+8;
    if (fieldName[0]=='p' && strcmp(fieldName, "pduLen")==0) return base+9;
    if (fieldName[0]=='s' && strcmp(fieldName, "seqNum")==0) return base+10;
    if (fieldName[0]=='h' && strcmp(fieldName, "hopCount")==0) return base+11;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *PDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    static const char *fieldTypeStrings[] = {
        "string",
        "unsigned int",
        "Address",
        "Address",
        "APN",
        "APN",
        "ConnectionId",
        "int",
        "int",
        "unsigned int",
        "unsigned int",
        "unsigned int",
    };
    return (field>=0 && field<12) ? fieldTypeStrings[field] : nullptr;
}

const char **PDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 7: {
            static const char *names[] = { "enum",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *PDUDescriptor::getFieldProperty(int field, const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldProperty(field, propertyname);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 7:
            if (!strcmp(propertyname,"enum")) return "PDUType";
            return nullptr;
        default: return nullptr;
    }
}

int PDUDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    PDU_Base *pp = (PDU_Base *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string PDUDescriptor::getFieldValueAsString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldValueAsString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    PDU_Base *pp = (PDU_Base *)object; (void)pp;
    switch (field) {
        case 0: return oppstring2string(pp->getDisplayString());
        case 1: return ulong2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getSrcAddr(); return out.str();}
        case 3: {std::stringstream out; out << pp->getDstAddr(); return out.str();}
        case 4: {std::stringstream out; out << pp->getSrcApn(); return out.str();}
        case 5: {std::stringstream out; out << pp->getDstApn(); return out.str();}
        case 6: {std::stringstream out; out << pp->getConnId(); return out.str();}
        case 7: return enum2string(pp->getType(), "PDUType");
        case 8: return long2string(pp->getFlags());
        case 9: return ulong2string(pp->getPduLen());
        case 10: return ulong2string(pp->getSeqNum());
        case 11: return ulong2string(pp->getHopCount());
        default: return "";
    }
}

bool PDUDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->setFieldValueAsString(object,field,i,value);
        field -= basedesc->getFieldCount();
    }
    PDU_Base *pp = (PDU_Base *)object; (void)pp;
    switch (field) {
        case 0: pp->setDisplayString((value)); return true;
        case 1: pp->setVersion(string2ulong(value)); return true;
        case 7: pp->setType((PDUType)string2enum(value, "PDUType")); return true;
        case 8: pp->setFlags(string2long(value)); return true;
        case 9: pp->setPduLen(string2ulong(value)); return true;
        case 10: pp->setSeqNum(string2ulong(value)); return true;
        case 11: pp->setHopCount(string2ulong(value)); return true;
        default: return false;
    }
}

const char *PDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(Address));
        case 3: return omnetpp::opp_typename(typeid(Address));
        case 4: return omnetpp::opp_typename(typeid(APN));
        case 5: return omnetpp::opp_typename(typeid(APN));
        case 6: return omnetpp::opp_typename(typeid(ConnectionId));
        default: return nullptr;
    };
}

void *PDUDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructValuePointer(object, field, i);
        field -= basedesc->getFieldCount();
    }
    PDU_Base *pp = (PDU_Base *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getSrcAddr()); break;
        case 3: return (void *)(&pp->getDstAddr()); break;
        case 4: return (void *)(&pp->getSrcApn()); break;
        case 5: return (void *)(&pp->getDstApn()); break;
        case 6: return (void *)(&pp->getConnId()); break;
        default: return nullptr;
    }
}