ControlPDU_m.cc

Go to the documentation of this file.

//
// Generated file, do not edit! Created by nedtool 5.0 from DIF/EFCP/DTCP/ControlPDU.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 "ControlPDU_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;
}

Register_Class(ControlPDU);

ControlPDU::ControlPDU(const char *name, int kind) : ::PDU(name,kind)
{
    this->setType(-1);
}

ControlPDU::ControlPDU(const ControlPDU& other) : ::PDU(other)
{
    copy(other);
}

ControlPDU::~ControlPDU()
{
}

ControlPDU& ControlPDU::operator=(const ControlPDU& other)
{
    if (this==&other) return *this;
    ::PDU::operator=(other);
    copy(other);
    return *this;
}

void ControlPDU::copy(const ControlPDU& other)
{
}

void ControlPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::PDU::parsimPack(b);
}

void ControlPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::PDU::parsimUnpack(b);
}

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

    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(ControlPDUDescriptor);

ControlPDUDescriptor::ControlPDUDescriptor() : omnetpp::cClassDescriptor("ControlPDU", "PDU")
{
    propertynames = nullptr;
}

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

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

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

const char *ControlPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int ControlPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *ControlPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int ControlPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *ControlPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **ControlPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *ControlPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string ControlPDUDescriptor::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();
    }
    ControlPDU *pp = (ControlPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool ControlPDUDescriptor::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();
    }
    ControlPDU *pp = (ControlPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *ControlPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *ControlPDUDescriptor::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();
    }
    ControlPDU *pp = (ControlPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(NAckPDU);

NAckPDU::NAckPDU(const char *name, int kind) : ::ControlPDU(name,kind)
{
    this->ackNackSeqNum = 0;
}

NAckPDU::NAckPDU(const NAckPDU& other) : ::ControlPDU(other)
{
    copy(other);
}

NAckPDU::~NAckPDU()
{
}

NAckPDU& NAckPDU::operator=(const NAckPDU& other)
{
    if (this==&other) return *this;
    ::ControlPDU::operator=(other);
    copy(other);
    return *this;
}

void NAckPDU::copy(const NAckPDU& other)
{
    this->ackNackSeqNum = other.ackNackSeqNum;
}

void NAckPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::ControlPDU::parsimPack(b);
    doParsimPacking(b,this->ackNackSeqNum);
}

void NAckPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::ControlPDU::parsimUnpack(b);
    doParsimUnpacking(b,this->ackNackSeqNum);
}

unsigned int NAckPDU::getAckNackSeqNum() const
{
    return this->ackNackSeqNum;
}

void NAckPDU::setAckNackSeqNum(unsigned int ackNackSeqNum)
{
    this->ackNackSeqNum = ackNackSeqNum;
}

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

    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(NAckPDUDescriptor);

NAckPDUDescriptor::NAckPDUDescriptor() : omnetpp::cClassDescriptor("NAckPDU", "ControlPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *NAckPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int NAckPDUDescriptor::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,
    };
    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
}

const char *NAckPDUDescriptor::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[] = {
        "ackNackSeqNum",
    };
    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
}

int NAckPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='a' && strcmp(fieldName, "ackNackSeqNum")==0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *NAckPDUDescriptor::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[] = {
        "unsigned int",
    };
    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
}

const char **NAckPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *NAckPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string NAckPDUDescriptor::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();
    }
    NAckPDU *pp = (NAckPDU *)object; (void)pp;
    switch (field) {
        case 0: return ulong2string(pp->getAckNackSeqNum());
        default: return "";
    }
}

bool NAckPDUDescriptor::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();
    }
    NAckPDU *pp = (NAckPDU *)object; (void)pp;
    switch (field) {
        case 0: pp->setAckNackSeqNum(string2ulong(value)); return true;
        default: return false;
    }
}

const char *NAckPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    };
}

void *NAckPDUDescriptor::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();
    }
    NAckPDU *pp = (NAckPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(FlowControlPDU);

FlowControlPDU::FlowControlPDU(const char *name, int kind) : ::NAckPDU(name,kind)
{
    this->rcvRightWinEdge = 0;
    this->rcvRate = 0;
    this->timeUnit = 0;
    this->sndLeftWinEdge = 0;
    this->sndRightWinEdge = 0;
    this->sndRate = 0;
}

FlowControlPDU::FlowControlPDU(const FlowControlPDU& other) : ::NAckPDU(other)
{
    copy(other);
}

FlowControlPDU::~FlowControlPDU()
{
}

FlowControlPDU& FlowControlPDU::operator=(const FlowControlPDU& other)
{
    if (this==&other) return *this;
    ::NAckPDU::operator=(other);
    copy(other);
    return *this;
}

void FlowControlPDU::copy(const FlowControlPDU& other)
{
    this->rcvRightWinEdge = other.rcvRightWinEdge;
    this->rcvRate = other.rcvRate;
    this->timeUnit = other.timeUnit;
    this->sndLeftWinEdge = other.sndLeftWinEdge;
    this->sndRightWinEdge = other.sndRightWinEdge;
    this->sndRate = other.sndRate;
}

void FlowControlPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::NAckPDU::parsimPack(b);
    doParsimPacking(b,this->rcvRightWinEdge);
    doParsimPacking(b,this->rcvRate);
    doParsimPacking(b,this->timeUnit);
    doParsimPacking(b,this->sndLeftWinEdge);
    doParsimPacking(b,this->sndRightWinEdge);
    doParsimPacking(b,this->sndRate);
}

void FlowControlPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::NAckPDU::parsimUnpack(b);
    doParsimUnpacking(b,this->rcvRightWinEdge);
    doParsimUnpacking(b,this->rcvRate);
    doParsimUnpacking(b,this->timeUnit);
    doParsimUnpacking(b,this->sndLeftWinEdge);
    doParsimUnpacking(b,this->sndRightWinEdge);
    doParsimUnpacking(b,this->sndRate);
}

unsigned int FlowControlPDU::getRcvRightWinEdge() const
{
    return this->rcvRightWinEdge;
}

void FlowControlPDU::setRcvRightWinEdge(unsigned int rcvRightWinEdge)
{
    this->rcvRightWinEdge = rcvRightWinEdge;
}

unsigned int FlowControlPDU::getRcvRate() const
{
    return this->rcvRate;
}

void FlowControlPDU::setRcvRate(unsigned int rcvRate)
{
    this->rcvRate = rcvRate;
}

unsigned long FlowControlPDU::getTimeUnit() const
{
    return this->timeUnit;
}

void FlowControlPDU::setTimeUnit(unsigned long timeUnit)
{
    this->timeUnit = timeUnit;
}

unsigned int FlowControlPDU::getSndLeftWinEdge() const
{
    return this->sndLeftWinEdge;
}

void FlowControlPDU::setSndLeftWinEdge(unsigned int sndLeftWinEdge)
{
    this->sndLeftWinEdge = sndLeftWinEdge;
}

unsigned int FlowControlPDU::getSndRightWinEdge() const
{
    return this->sndRightWinEdge;
}

void FlowControlPDU::setSndRightWinEdge(unsigned int sndRightWinEdge)
{
    this->sndRightWinEdge = sndRightWinEdge;
}

unsigned int FlowControlPDU::getSndRate() const
{
    return this->sndRate;
}

void FlowControlPDU::setSndRate(unsigned int sndRate)
{
    this->sndRate = sndRate;
}

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

    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(FlowControlPDUDescriptor);

FlowControlPDUDescriptor::FlowControlPDUDescriptor() : omnetpp::cClassDescriptor("FlowControlPDU", "NAckPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *FlowControlPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int FlowControlPDUDescriptor::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_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
    };
    return (field>=0 && field<6) ? fieldTypeFlags[field] : 0;
}

const char *FlowControlPDUDescriptor::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[] = {
        "rcvRightWinEdge",
        "rcvRate",
        "timeUnit",
        "sndLeftWinEdge",
        "sndRightWinEdge",
        "sndRate",
    };
    return (field>=0 && field<6) ? fieldNames[field] : nullptr;
}

int FlowControlPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='r' && strcmp(fieldName, "rcvRightWinEdge")==0) return base+0;
    if (fieldName[0]=='r' && strcmp(fieldName, "rcvRate")==0) return base+1;
    if (fieldName[0]=='t' && strcmp(fieldName, "timeUnit")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "sndLeftWinEdge")==0) return base+3;
    if (fieldName[0]=='s' && strcmp(fieldName, "sndRightWinEdge")==0) return base+4;
    if (fieldName[0]=='s' && strcmp(fieldName, "sndRate")==0) return base+5;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *FlowControlPDUDescriptor::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[] = {
        "unsigned int",
        "unsigned int",
        "unsigned long",
        "unsigned int",
        "unsigned int",
        "unsigned int",
    };
    return (field>=0 && field<6) ? fieldTypeStrings[field] : nullptr;
}

const char **FlowControlPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *FlowControlPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string FlowControlPDUDescriptor::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();
    }
    FlowControlPDU *pp = (FlowControlPDU *)object; (void)pp;
    switch (field) {
        case 0: return ulong2string(pp->getRcvRightWinEdge());
        case 1: return ulong2string(pp->getRcvRate());
        case 2: return ulong2string(pp->getTimeUnit());
        case 3: return ulong2string(pp->getSndLeftWinEdge());
        case 4: return ulong2string(pp->getSndRightWinEdge());
        case 5: return ulong2string(pp->getSndRate());
        default: return "";
    }
}

bool FlowControlPDUDescriptor::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();
    }
    FlowControlPDU *pp = (FlowControlPDU *)object; (void)pp;
    switch (field) {
        case 0: pp->setRcvRightWinEdge(string2ulong(value)); return true;
        case 1: pp->setRcvRate(string2ulong(value)); return true;
        case 2: pp->setTimeUnit(string2ulong(value)); return true;
        case 3: pp->setSndLeftWinEdge(string2ulong(value)); return true;
        case 4: pp->setSndRightWinEdge(string2ulong(value)); return true;
        case 5: pp->setSndRate(string2ulong(value)); return true;
        default: return false;
    }
}

const char *FlowControlPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    };
}

void *FlowControlPDUDescriptor::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();
    }
    FlowControlPDU *pp = (FlowControlPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(AckOnlyPDU);

AckOnlyPDU::AckOnlyPDU(const char *name, int kind) : ::NAckPDU(name,kind)
{
    this->setType(ACK_ONLY_PDU);
}

AckOnlyPDU::AckOnlyPDU(const AckOnlyPDU& other) : ::NAckPDU(other)
{
    copy(other);
}

AckOnlyPDU::~AckOnlyPDU()
{
}

AckOnlyPDU& AckOnlyPDU::operator=(const AckOnlyPDU& other)
{
    if (this==&other) return *this;
    ::NAckPDU::operator=(other);
    copy(other);
    return *this;
}

void AckOnlyPDU::copy(const AckOnlyPDU& other)
{
}

void AckOnlyPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::NAckPDU::parsimPack(b);
}

void AckOnlyPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::NAckPDU::parsimUnpack(b);
}

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

    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(AckOnlyPDUDescriptor);

AckOnlyPDUDescriptor::AckOnlyPDUDescriptor() : omnetpp::cClassDescriptor("AckOnlyPDU", "NAckPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *AckOnlyPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int AckOnlyPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *AckOnlyPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int AckOnlyPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *AckOnlyPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **AckOnlyPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *AckOnlyPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string AckOnlyPDUDescriptor::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();
    }
    AckOnlyPDU *pp = (AckOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool AckOnlyPDUDescriptor::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();
    }
    AckOnlyPDU *pp = (AckOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *AckOnlyPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *AckOnlyPDUDescriptor::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();
    }
    AckOnlyPDU *pp = (AckOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(NackOnlyPDU);

NackOnlyPDU::NackOnlyPDU(const char *name, int kind) : ::NAckPDU(name,kind)
{
    this->setType(NACK_ONLY_PDU);
}

NackOnlyPDU::NackOnlyPDU(const NackOnlyPDU& other) : ::NAckPDU(other)
{
    copy(other);
}

NackOnlyPDU::~NackOnlyPDU()
{
}

NackOnlyPDU& NackOnlyPDU::operator=(const NackOnlyPDU& other)
{
    if (this==&other) return *this;
    ::NAckPDU::operator=(other);
    copy(other);
    return *this;
}

void NackOnlyPDU::copy(const NackOnlyPDU& other)
{
}

void NackOnlyPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::NAckPDU::parsimPack(b);
}

void NackOnlyPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::NAckPDU::parsimUnpack(b);
}

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

    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(NackOnlyPDUDescriptor);

NackOnlyPDUDescriptor::NackOnlyPDUDescriptor() : omnetpp::cClassDescriptor("NackOnlyPDU", "NAckPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *NackOnlyPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int NackOnlyPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *NackOnlyPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int NackOnlyPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *NackOnlyPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **NackOnlyPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *NackOnlyPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string NackOnlyPDUDescriptor::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();
    }
    NackOnlyPDU *pp = (NackOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool NackOnlyPDUDescriptor::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();
    }
    NackOnlyPDU *pp = (NackOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *NackOnlyPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *NackOnlyPDUDescriptor::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();
    }
    NackOnlyPDU *pp = (NackOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(AckFlowPDU);

AckFlowPDU::AckFlowPDU(const char *name, int kind) : ::FlowControlPDU(name,kind)
{
    this->setType(ACK_FLOW_PDU);
}

AckFlowPDU::AckFlowPDU(const AckFlowPDU& other) : ::FlowControlPDU(other)
{
    copy(other);
}

AckFlowPDU::~AckFlowPDU()
{
}

AckFlowPDU& AckFlowPDU::operator=(const AckFlowPDU& other)
{
    if (this==&other) return *this;
    ::FlowControlPDU::operator=(other);
    copy(other);
    return *this;
}

void AckFlowPDU::copy(const AckFlowPDU& other)
{
}

void AckFlowPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::FlowControlPDU::parsimPack(b);
}

void AckFlowPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::FlowControlPDU::parsimUnpack(b);
}

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

    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(AckFlowPDUDescriptor);

AckFlowPDUDescriptor::AckFlowPDUDescriptor() : omnetpp::cClassDescriptor("AckFlowPDU", "FlowControlPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *AckFlowPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int AckFlowPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *AckFlowPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int AckFlowPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *AckFlowPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **AckFlowPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *AckFlowPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string AckFlowPDUDescriptor::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();
    }
    AckFlowPDU *pp = (AckFlowPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool AckFlowPDUDescriptor::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();
    }
    AckFlowPDU *pp = (AckFlowPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *AckFlowPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *AckFlowPDUDescriptor::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();
    }
    AckFlowPDU *pp = (AckFlowPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(NackFlowPDU);

NackFlowPDU::NackFlowPDU(const char *name, int kind) : ::FlowControlPDU(name,kind)
{
    this->setType(NACK_FLOW_PDU);
}

NackFlowPDU::NackFlowPDU(const NackFlowPDU& other) : ::FlowControlPDU(other)
{
    copy(other);
}

NackFlowPDU::~NackFlowPDU()
{
}

NackFlowPDU& NackFlowPDU::operator=(const NackFlowPDU& other)
{
    if (this==&other) return *this;
    ::FlowControlPDU::operator=(other);
    copy(other);
    return *this;
}

void NackFlowPDU::copy(const NackFlowPDU& other)
{
}

void NackFlowPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::FlowControlPDU::parsimPack(b);
}

void NackFlowPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::FlowControlPDU::parsimUnpack(b);
}

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

    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(NackFlowPDUDescriptor);

NackFlowPDUDescriptor::NackFlowPDUDescriptor() : omnetpp::cClassDescriptor("NackFlowPDU", "FlowControlPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *NackFlowPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int NackFlowPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *NackFlowPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int NackFlowPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *NackFlowPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **NackFlowPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *NackFlowPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string NackFlowPDUDescriptor::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();
    }
    NackFlowPDU *pp = (NackFlowPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool NackFlowPDUDescriptor::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();
    }
    NackFlowPDU *pp = (NackFlowPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *NackFlowPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *NackFlowPDUDescriptor::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();
    }
    NackFlowPDU *pp = (NackFlowPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(FlowControlOnlyPDU);

FlowControlOnlyPDU::FlowControlOnlyPDU(const char *name, int kind) : ::FlowControlPDU(name,kind)
{
    this->setType(FLOW_ONLY_PDU);
}

FlowControlOnlyPDU::FlowControlOnlyPDU(const FlowControlOnlyPDU& other) : ::FlowControlPDU(other)
{
    copy(other);
}

FlowControlOnlyPDU::~FlowControlOnlyPDU()
{
}

FlowControlOnlyPDU& FlowControlOnlyPDU::operator=(const FlowControlOnlyPDU& other)
{
    if (this==&other) return *this;
    ::FlowControlPDU::operator=(other);
    copy(other);
    return *this;
}

void FlowControlOnlyPDU::copy(const FlowControlOnlyPDU& other)
{
}

void FlowControlOnlyPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::FlowControlPDU::parsimPack(b);
}

void FlowControlOnlyPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::FlowControlPDU::parsimUnpack(b);
}

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

    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(FlowControlOnlyPDUDescriptor);

FlowControlOnlyPDUDescriptor::FlowControlOnlyPDUDescriptor() : omnetpp::cClassDescriptor("FlowControlOnlyPDU", "FlowControlPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *FlowControlOnlyPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int FlowControlOnlyPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *FlowControlOnlyPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int FlowControlOnlyPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *FlowControlOnlyPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **FlowControlOnlyPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *FlowControlOnlyPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string FlowControlOnlyPDUDescriptor::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();
    }
    FlowControlOnlyPDU *pp = (FlowControlOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool FlowControlOnlyPDUDescriptor::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();
    }
    FlowControlOnlyPDU *pp = (FlowControlOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *FlowControlOnlyPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *FlowControlOnlyPDUDescriptor::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();
    }
    FlowControlOnlyPDU *pp = (FlowControlOnlyPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(SelectiveNAckFlow);

SelectiveNAckFlow::SelectiveNAckFlow(const char *name, int kind) : ::FlowControlPDU(name,kind)
{
    this->newLeftWinEdge = 0;
    this->nackListLen = 0;
    nackList_arraysize = 0;
    this->nackList = 0;
}

SelectiveNAckFlow::SelectiveNAckFlow(const SelectiveNAckFlow& other) : ::FlowControlPDU(other)
{
    nackList_arraysize = 0;
    this->nackList = 0;
    copy(other);
}

SelectiveNAckFlow::~SelectiveNAckFlow()
{
    delete [] this->nackList;
}

SelectiveNAckFlow& SelectiveNAckFlow::operator=(const SelectiveNAckFlow& other)
{
    if (this==&other) return *this;
    ::FlowControlPDU::operator=(other);
    copy(other);
    return *this;
}

void SelectiveNAckFlow::copy(const SelectiveNAckFlow& other)
{
    this->newLeftWinEdge = other.newLeftWinEdge;
    this->nackListLen = other.nackListLen;
    delete [] this->nackList;
    this->nackList = (other.nackList_arraysize==0) ? nullptr : new unsigned int[other.nackList_arraysize];
    nackList_arraysize = other.nackList_arraysize;
    for (unsigned int i=0; i<nackList_arraysize; i++)
        this->nackList[i] = other.nackList[i];
}

void SelectiveNAckFlow::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::FlowControlPDU::parsimPack(b);
    doParsimPacking(b,this->newLeftWinEdge);
    doParsimPacking(b,this->nackListLen);
    b->pack(nackList_arraysize);
    doParsimArrayPacking(b,this->nackList,nackList_arraysize);
}

void SelectiveNAckFlow::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::FlowControlPDU::parsimUnpack(b);
    doParsimUnpacking(b,this->newLeftWinEdge);
    doParsimUnpacking(b,this->nackListLen);
    delete [] this->nackList;
    b->unpack(nackList_arraysize);
    if (nackList_arraysize==0) {
        this->nackList = 0;
    } else {
        this->nackList = new unsigned int[nackList_arraysize];
        doParsimArrayUnpacking(b,this->nackList,nackList_arraysize);
    }
}

unsigned int SelectiveNAckFlow::getNewLeftWinEdge() const
{
    return this->newLeftWinEdge;
}

void SelectiveNAckFlow::setNewLeftWinEdge(unsigned int newLeftWinEdge)
{
    this->newLeftWinEdge = newLeftWinEdge;
}

unsigned int SelectiveNAckFlow::getNackListLen() const
{
    return this->nackListLen;
}

void SelectiveNAckFlow::setNackListLen(unsigned int nackListLen)
{
    this->nackListLen = nackListLen;
}

void SelectiveNAckFlow::setNackListArraySize(unsigned int size)
{
    unsigned int *nackList2 = (size==0) ? nullptr : new unsigned int[size];
    unsigned int sz = nackList_arraysize < size ? nackList_arraysize : size;
    for (unsigned int i=0; i<sz; i++)
        nackList2[i] = this->nackList[i];
    for (unsigned int i=sz; i<size; i++)
        nackList2[i] = 0;
    nackList_arraysize = size;
    delete [] this->nackList;
    this->nackList = nackList2;
}

unsigned int SelectiveNAckFlow::getNackListArraySize() const
{
    return nackList_arraysize;
}

unsigned int SelectiveNAckFlow::getNackList(unsigned int k) const
{
    if (k>=nackList_arraysize) throw omnetpp::cRuntimeError("Array of size %d indexed by %d", nackList_arraysize, k);
    return this->nackList[k];
}

void SelectiveNAckFlow::setNackList(unsigned int k, unsigned int nackList)
{
    if (k>=nackList_arraysize) throw omnetpp::cRuntimeError("Array of size %d indexed by %d", nackList_arraysize, k);
    this->nackList[k] = nackList;
}

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

    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(SelectiveNAckFlowDescriptor);

SelectiveNAckFlowDescriptor::SelectiveNAckFlowDescriptor() : omnetpp::cClassDescriptor("SelectiveNAckFlow", "FlowControlPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *SelectiveNAckFlowDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int SelectiveNAckFlowDescriptor::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_ISARRAY | FD_ISEDITABLE,
    };
    return (field>=0 && field<3) ? fieldTypeFlags[field] : 0;
}

const char *SelectiveNAckFlowDescriptor::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[] = {
        "newLeftWinEdge",
        "nackListLen",
        "nackList",
    };
    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
}

int SelectiveNAckFlowDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='n' && strcmp(fieldName, "newLeftWinEdge")==0) return base+0;
    if (fieldName[0]=='n' && strcmp(fieldName, "nackListLen")==0) return base+1;
    if (fieldName[0]=='n' && strcmp(fieldName, "nackList")==0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *SelectiveNAckFlowDescriptor::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[] = {
        "unsigned int",
        "unsigned int",
        "unsigned int",
    };
    return (field>=0 && field<3) ? fieldTypeStrings[field] : nullptr;
}

const char **SelectiveNAckFlowDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *SelectiveNAckFlowDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string SelectiveNAckFlowDescriptor::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();
    }
    SelectiveNAckFlow *pp = (SelectiveNAckFlow *)object; (void)pp;
    switch (field) {
        case 0: return ulong2string(pp->getNewLeftWinEdge());
        case 1: return ulong2string(pp->getNackListLen());
        case 2: return ulong2string(pp->getNackList(i));
        default: return "";
    }
}

bool SelectiveNAckFlowDescriptor::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();
    }
    SelectiveNAckFlow *pp = (SelectiveNAckFlow *)object; (void)pp;
    switch (field) {
        case 0: pp->setNewLeftWinEdge(string2ulong(value)); return true;
        case 1: pp->setNackListLen(string2ulong(value)); return true;
        case 2: pp->setNackList(i,string2ulong(value)); return true;
        default: return false;
    }
}

const char *SelectiveNAckFlowDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    };
}

void *SelectiveNAckFlowDescriptor::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();
    }
    SelectiveNAckFlow *pp = (SelectiveNAckFlow *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(SelectiveAckFlowPDU);

SelectiveAckFlowPDU::SelectiveAckFlowPDU(const char *name, int kind) : ::SelectiveNAckFlow(name,kind)
{
    this->setType(SELECT_ACK_FLOW_PDU);
}

SelectiveAckFlowPDU::SelectiveAckFlowPDU(const SelectiveAckFlowPDU& other) : ::SelectiveNAckFlow(other)
{
    copy(other);
}

SelectiveAckFlowPDU::~SelectiveAckFlowPDU()
{
}

SelectiveAckFlowPDU& SelectiveAckFlowPDU::operator=(const SelectiveAckFlowPDU& other)
{
    if (this==&other) return *this;
    ::SelectiveNAckFlow::operator=(other);
    copy(other);
    return *this;
}

void SelectiveAckFlowPDU::copy(const SelectiveAckFlowPDU& other)
{
}

void SelectiveAckFlowPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::SelectiveNAckFlow::parsimPack(b);
}

void SelectiveAckFlowPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::SelectiveNAckFlow::parsimUnpack(b);
}

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

    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(SelectiveAckFlowPDUDescriptor);

SelectiveAckFlowPDUDescriptor::SelectiveAckFlowPDUDescriptor() : omnetpp::cClassDescriptor("SelectiveAckFlowPDU", "SelectiveNAckFlow")
{
    propertynames = nullptr;
}

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

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

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

const char *SelectiveAckFlowPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int SelectiveAckFlowPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *SelectiveAckFlowPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int SelectiveAckFlowPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *SelectiveAckFlowPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **SelectiveAckFlowPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *SelectiveAckFlowPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string SelectiveAckFlowPDUDescriptor::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();
    }
    SelectiveAckFlowPDU *pp = (SelectiveAckFlowPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool SelectiveAckFlowPDUDescriptor::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();
    }
    SelectiveAckFlowPDU *pp = (SelectiveAckFlowPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *SelectiveAckFlowPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *SelectiveAckFlowPDUDescriptor::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();
    }
    SelectiveAckFlowPDU *pp = (SelectiveAckFlowPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(SelectiveNackFlowPDU);

SelectiveNackFlowPDU::SelectiveNackFlowPDU(const char *name, int kind) : ::SelectiveNAckFlow(name,kind)
{
    this->setType(SELECT_NACK_FLOW_PDU);
}

SelectiveNackFlowPDU::SelectiveNackFlowPDU(const SelectiveNackFlowPDU& other) : ::SelectiveNAckFlow(other)
{
    copy(other);
}

SelectiveNackFlowPDU::~SelectiveNackFlowPDU()
{
}

SelectiveNackFlowPDU& SelectiveNackFlowPDU::operator=(const SelectiveNackFlowPDU& other)
{
    if (this==&other) return *this;
    ::SelectiveNAckFlow::operator=(other);
    copy(other);
    return *this;
}

void SelectiveNackFlowPDU::copy(const SelectiveNackFlowPDU& other)
{
}

void SelectiveNackFlowPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::SelectiveNAckFlow::parsimPack(b);
}

void SelectiveNackFlowPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::SelectiveNAckFlow::parsimUnpack(b);
}

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

    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(SelectiveNackFlowPDUDescriptor);

SelectiveNackFlowPDUDescriptor::SelectiveNackFlowPDUDescriptor() : omnetpp::cClassDescriptor("SelectiveNackFlowPDU", "SelectiveNAckFlow")
{
    propertynames = nullptr;
}

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

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

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

const char *SelectiveNackFlowPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int SelectiveNackFlowPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *SelectiveNackFlowPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int SelectiveNackFlowPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *SelectiveNackFlowPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **SelectiveNackFlowPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *SelectiveNackFlowPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string SelectiveNackFlowPDUDescriptor::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();
    }
    SelectiveNackFlowPDU *pp = (SelectiveNackFlowPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool SelectiveNackFlowPDUDescriptor::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();
    }
    SelectiveNackFlowPDU *pp = (SelectiveNackFlowPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *SelectiveNackFlowPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *SelectiveNackFlowPDUDescriptor::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();
    }
    SelectiveNackFlowPDU *pp = (SelectiveNackFlowPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(SelectiveAckPDU);

SelectiveAckPDU::SelectiveAckPDU(const char *name, int kind) : ::SelectiveNAckFlow(name,kind)
{
    this->setType(SELECT_ACK_PDU);
}

SelectiveAckPDU::SelectiveAckPDU(const SelectiveAckPDU& other) : ::SelectiveNAckFlow(other)
{
    copy(other);
}

SelectiveAckPDU::~SelectiveAckPDU()
{
}

SelectiveAckPDU& SelectiveAckPDU::operator=(const SelectiveAckPDU& other)
{
    if (this==&other) return *this;
    ::SelectiveNAckFlow::operator=(other);
    copy(other);
    return *this;
}

void SelectiveAckPDU::copy(const SelectiveAckPDU& other)
{
}

void SelectiveAckPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::SelectiveNAckFlow::parsimPack(b);
}

void SelectiveAckPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::SelectiveNAckFlow::parsimUnpack(b);
}

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

    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(SelectiveAckPDUDescriptor);

SelectiveAckPDUDescriptor::SelectiveAckPDUDescriptor() : omnetpp::cClassDescriptor("SelectiveAckPDU", "SelectiveNAckFlow")
{
    propertynames = nullptr;
}

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

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

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

const char *SelectiveAckPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int SelectiveAckPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *SelectiveAckPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int SelectiveAckPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *SelectiveAckPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **SelectiveAckPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *SelectiveAckPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string SelectiveAckPDUDescriptor::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();
    }
    SelectiveAckPDU *pp = (SelectiveAckPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool SelectiveAckPDUDescriptor::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();
    }
    SelectiveAckPDU *pp = (SelectiveAckPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *SelectiveAckPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *SelectiveAckPDUDescriptor::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();
    }
    SelectiveAckPDU *pp = (SelectiveAckPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(SelectiveNackPDU);

SelectiveNackPDU::SelectiveNackPDU(const char *name, int kind) : ::SelectiveNAckFlow(name,kind)
{
    this->setType(SELECT_NACK_PDU);
}

SelectiveNackPDU::SelectiveNackPDU(const SelectiveNackPDU& other) : ::SelectiveNAckFlow(other)
{
    copy(other);
}

SelectiveNackPDU::~SelectiveNackPDU()
{
}

SelectiveNackPDU& SelectiveNackPDU::operator=(const SelectiveNackPDU& other)
{
    if (this==&other) return *this;
    ::SelectiveNAckFlow::operator=(other);
    copy(other);
    return *this;
}

void SelectiveNackPDU::copy(const SelectiveNackPDU& other)
{
}

void SelectiveNackPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::SelectiveNAckFlow::parsimPack(b);
}

void SelectiveNackPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::SelectiveNAckFlow::parsimUnpack(b);
}

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

    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(SelectiveNackPDUDescriptor);

SelectiveNackPDUDescriptor::SelectiveNackPDUDescriptor() : omnetpp::cClassDescriptor("SelectiveNackPDU", "SelectiveNAckFlow")
{
    propertynames = nullptr;
}

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

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

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

const char *SelectiveNackPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int SelectiveNackPDUDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *SelectiveNackPDUDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int SelectiveNackPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *SelectiveNackPDUDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **SelectiveNackPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *SelectiveNackPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string SelectiveNackPDUDescriptor::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();
    }
    SelectiveNackPDU *pp = (SelectiveNackPDU *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool SelectiveNackPDUDescriptor::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();
    }
    SelectiveNackPDU *pp = (SelectiveNackPDU *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *SelectiveNackPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *SelectiveNackPDUDescriptor::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();
    }
    SelectiveNackPDU *pp = (SelectiveNackPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(ControlAckPDU);

ControlAckPDU::ControlAckPDU(const char *name, int kind) : ::ControlPDU(name,kind)
{
    this->setType(CONTROL_ACK_PDU);

    this->lastCtrlSeqNumRcv = 0;
    this->rcvLeftWinEdge = 0;
    this->rcvRightWinEdge = 0;
    this->sndLeftWinEdge = 0;
    this->sndRightWinEdge = 0;
    this->rcvRate = 0;
}

ControlAckPDU::ControlAckPDU(const ControlAckPDU& other) : ::ControlPDU(other)
{
    copy(other);
}

ControlAckPDU::~ControlAckPDU()
{
}

ControlAckPDU& ControlAckPDU::operator=(const ControlAckPDU& other)
{
    if (this==&other) return *this;
    ::ControlPDU::operator=(other);
    copy(other);
    return *this;
}

void ControlAckPDU::copy(const ControlAckPDU& other)
{
    this->lastCtrlSeqNumRcv = other.lastCtrlSeqNumRcv;
    this->rcvLeftWinEdge = other.rcvLeftWinEdge;
    this->rcvRightWinEdge = other.rcvRightWinEdge;
    this->sndLeftWinEdge = other.sndLeftWinEdge;
    this->sndRightWinEdge = other.sndRightWinEdge;
    this->rcvRate = other.rcvRate;
}

void ControlAckPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::ControlPDU::parsimPack(b);
    doParsimPacking(b,this->lastCtrlSeqNumRcv);
    doParsimPacking(b,this->rcvLeftWinEdge);
    doParsimPacking(b,this->rcvRightWinEdge);
    doParsimPacking(b,this->sndLeftWinEdge);
    doParsimPacking(b,this->sndRightWinEdge);
    doParsimPacking(b,this->rcvRate);
}

void ControlAckPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::ControlPDU::parsimUnpack(b);
    doParsimUnpacking(b,this->lastCtrlSeqNumRcv);
    doParsimUnpacking(b,this->rcvLeftWinEdge);
    doParsimUnpacking(b,this->rcvRightWinEdge);
    doParsimUnpacking(b,this->sndLeftWinEdge);
    doParsimUnpacking(b,this->sndRightWinEdge);
    doParsimUnpacking(b,this->rcvRate);
}

unsigned int ControlAckPDU::getLastCtrlSeqNumRcv() const
{
    return this->lastCtrlSeqNumRcv;
}

void ControlAckPDU::setLastCtrlSeqNumRcv(unsigned int lastCtrlSeqNumRcv)
{
    this->lastCtrlSeqNumRcv = lastCtrlSeqNumRcv;
}

unsigned int ControlAckPDU::getRcvLeftWinEdge() const
{
    return this->rcvLeftWinEdge;
}

void ControlAckPDU::setRcvLeftWinEdge(unsigned int rcvLeftWinEdge)
{
    this->rcvLeftWinEdge = rcvLeftWinEdge;
}

unsigned int ControlAckPDU::getRcvRightWinEdge() const
{
    return this->rcvRightWinEdge;
}

void ControlAckPDU::setRcvRightWinEdge(unsigned int rcvRightWinEdge)
{
    this->rcvRightWinEdge = rcvRightWinEdge;
}

unsigned int ControlAckPDU::getSndLeftWinEdge() const
{
    return this->sndLeftWinEdge;
}

void ControlAckPDU::setSndLeftWinEdge(unsigned int sndLeftWinEdge)
{
    this->sndLeftWinEdge = sndLeftWinEdge;
}

unsigned int ControlAckPDU::getSndRightWinEdge() const
{
    return this->sndRightWinEdge;
}

void ControlAckPDU::setSndRightWinEdge(unsigned int sndRightWinEdge)
{
    this->sndRightWinEdge = sndRightWinEdge;
}

unsigned int ControlAckPDU::getRcvRate() const
{
    return this->rcvRate;
}

void ControlAckPDU::setRcvRate(unsigned int rcvRate)
{
    this->rcvRate = rcvRate;
}

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

    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(ControlAckPDUDescriptor);

ControlAckPDUDescriptor::ControlAckPDUDescriptor() : omnetpp::cClassDescriptor("ControlAckPDU", "ControlPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *ControlAckPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int ControlAckPDUDescriptor::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_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
    };
    return (field>=0 && field<6) ? fieldTypeFlags[field] : 0;
}

const char *ControlAckPDUDescriptor::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[] = {
        "lastCtrlSeqNumRcv",
        "rcvLeftWinEdge",
        "rcvRightWinEdge",
        "sndLeftWinEdge",
        "sndRightWinEdge",
        "rcvRate",
    };
    return (field>=0 && field<6) ? fieldNames[field] : nullptr;
}

int ControlAckPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='l' && strcmp(fieldName, "lastCtrlSeqNumRcv")==0) return base+0;
    if (fieldName[0]=='r' && strcmp(fieldName, "rcvLeftWinEdge")==0) return base+1;
    if (fieldName[0]=='r' && strcmp(fieldName, "rcvRightWinEdge")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "sndLeftWinEdge")==0) return base+3;
    if (fieldName[0]=='s' && strcmp(fieldName, "sndRightWinEdge")==0) return base+4;
    if (fieldName[0]=='r' && strcmp(fieldName, "rcvRate")==0) return base+5;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *ControlAckPDUDescriptor::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[] = {
        "unsigned int",
        "unsigned int",
        "unsigned int",
        "unsigned int",
        "unsigned int",
        "unsigned int",
    };
    return (field>=0 && field<6) ? fieldTypeStrings[field] : nullptr;
}

const char **ControlAckPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *ControlAckPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string ControlAckPDUDescriptor::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();
    }
    ControlAckPDU *pp = (ControlAckPDU *)object; (void)pp;
    switch (field) {
        case 0: return ulong2string(pp->getLastCtrlSeqNumRcv());
        case 1: return ulong2string(pp->getRcvLeftWinEdge());
        case 2: return ulong2string(pp->getRcvRightWinEdge());
        case 3: return ulong2string(pp->getSndLeftWinEdge());
        case 4: return ulong2string(pp->getSndRightWinEdge());
        case 5: return ulong2string(pp->getRcvRate());
        default: return "";
    }
}

bool ControlAckPDUDescriptor::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();
    }
    ControlAckPDU *pp = (ControlAckPDU *)object; (void)pp;
    switch (field) {
        case 0: pp->setLastCtrlSeqNumRcv(string2ulong(value)); return true;
        case 1: pp->setRcvLeftWinEdge(string2ulong(value)); return true;
        case 2: pp->setRcvRightWinEdge(string2ulong(value)); return true;
        case 3: pp->setSndLeftWinEdge(string2ulong(value)); return true;
        case 4: pp->setSndRightWinEdge(string2ulong(value)); return true;
        case 5: pp->setRcvRate(string2ulong(value)); return true;
        default: return false;
    }
}

const char *ControlAckPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    };
}

void *ControlAckPDUDescriptor::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();
    }
    ControlAckPDU *pp = (ControlAckPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

Register_Class(RendezvousPDU);

RendezvousPDU::RendezvousPDU(const char *name, int kind) : ::ControlAckPDU(name,kind)
{
    this->setType(RENDEZVOUS_PDU);

    this->rendezSeqNum = 0;
}

RendezvousPDU::RendezvousPDU(const RendezvousPDU& other) : ::ControlAckPDU(other)
{
    copy(other);
}

RendezvousPDU::~RendezvousPDU()
{
}

RendezvousPDU& RendezvousPDU::operator=(const RendezvousPDU& other)
{
    if (this==&other) return *this;
    ::ControlAckPDU::operator=(other);
    copy(other);
    return *this;
}

void RendezvousPDU::copy(const RendezvousPDU& other)
{
    this->rendezSeqNum = other.rendezSeqNum;
}

void RendezvousPDU::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::ControlAckPDU::parsimPack(b);
    doParsimPacking(b,this->rendezSeqNum);
}

void RendezvousPDU::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::ControlAckPDU::parsimUnpack(b);
    doParsimUnpacking(b,this->rendezSeqNum);
}

unsigned int RendezvousPDU::getRendezSeqNum() const
{
    return this->rendezSeqNum;
}

void RendezvousPDU::setRendezSeqNum(unsigned int rendezSeqNum)
{
    this->rendezSeqNum = rendezSeqNum;
}

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

    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(RendezvousPDUDescriptor);

RendezvousPDUDescriptor::RendezvousPDUDescriptor() : omnetpp::cClassDescriptor("RendezvousPDU", "ControlAckPDU")
{
    propertynames = nullptr;
}

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

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

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

const char *RendezvousPDUDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int RendezvousPDUDescriptor::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,
    };
    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
}

const char *RendezvousPDUDescriptor::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[] = {
        "rendezSeqNum",
    };
    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
}

int RendezvousPDUDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='r' && strcmp(fieldName, "rendezSeqNum")==0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *RendezvousPDUDescriptor::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[] = {
        "unsigned int",
    };
    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
}

const char **RendezvousPDUDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    }
}

const char *RendezvousPDUDescriptor::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) {
        default: return nullptr;
    }
}

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

std::string RendezvousPDUDescriptor::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();
    }
    RendezvousPDU *pp = (RendezvousPDU *)object; (void)pp;
    switch (field) {
        case 0: return ulong2string(pp->getRendezSeqNum());
        default: return "";
    }
}

bool RendezvousPDUDescriptor::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();
    }
    RendezvousPDU *pp = (RendezvousPDU *)object; (void)pp;
    switch (field) {
        case 0: pp->setRendezSeqNum(string2ulong(value)); return true;
        default: return false;
    }
}

const char *RendezvousPDUDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        default: return nullptr;
    };
}

void *RendezvousPDUDescriptor::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();
    }
    RendezvousPDU *pp = (RendezvousPDU *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}