CDAPMessage_m.cc

Go to the documentation of this file.

//
// Generated file, do not edit! Created by nedtool 5.0 from DAF/CDAP/CDAPMessage.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 "CDAPMessage_m.h"

namespace omnetpp {

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

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

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

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

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

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

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

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

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

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

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

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

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

}  // namespace omnetpp


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

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

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

EXECUTE_ON_STARTUP(
    omnetpp::cEnum *e = omnetpp::cEnum::find("opCode_t");
    if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("opCode_t"));
    e->insert(UNKNOWN, "UNKNOWN");
    e->insert(M_CONNECT, "M_CONNECT");
    e->insert(M_CONNECT_R, "M_CONNECT_R");
    e->insert(M_RELEASE, "M_RELEASE");
    e->insert(M_RELEASE_R, "M_RELEASE_R");
    e->insert(M_CREATE, "M_CREATE");
    e->insert(M_CREATE_R, "M_CREATE_R");
    e->insert(M_DELETE, "M_DELETE");
    e->insert(M_DELETE_R, "M_DELETE_R");
    e->insert(M_READ, "M_READ");
    e->insert(M_READ_R, "M_READ_R");
    e->insert(M_CANCELREAD, "M_CANCELREAD");
    e->insert(M_CANCELREAD_R, "M_CANCELREAD_R");
    e->insert(M_WRITE, "M_WRITE");
    e->insert(M_WRITE_R, "M_WRITE_R");
    e->insert(M_START, "M_START");
    e->insert(M_START_R, "M_START_R");
    e->insert(M_STOP, "M_STOP");
    e->insert(M_STOP_R, "M_STOP_R");
);

EXECUTE_ON_STARTUP(
    omnetpp::cEnum *e = omnetpp::cEnum::find("flagValues_t");
    if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("flagValues_t"));
    e->insert(F_SYNC, "F_SYNC");
    e->insert(F_RD_INCOMPLETE, "F_RD_INCOMPLETE");
);

objVal_t::objVal_t()
{
    this->intval = 0;
    this->sintval = 0;
    this->int64val = 0;
    this->sint64val = 0;
    this->floatval = 0;
    this->doubleval = 0;
}

void __doPacking(omnetpp::cCommBuffer *b, const objVal_t& a)
{
    doParsimPacking(b,a.intval);
    doParsimPacking(b,a.sintval);
    doParsimPacking(b,a.int64val);
    doParsimPacking(b,a.sint64val);
    doParsimPacking(b,a.strval);
    doParsimPacking(b,a.floatval);
    doParsimPacking(b,a.doubleval);
}

void __doUnpacking(omnetpp::cCommBuffer *b, objVal_t& a)
{
    doParsimUnpacking(b,a.intval);
    doParsimUnpacking(b,a.sintval);
    doParsimUnpacking(b,a.int64val);
    doParsimUnpacking(b,a.sint64val);
    doParsimUnpacking(b,a.strval);
    doParsimUnpacking(b,a.floatval);
    doParsimUnpacking(b,a.doubleval);
}

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

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

objVal_tDescriptor::objVal_tDescriptor() : omnetpp::cClassDescriptor("objVal_t", "")
{
    propertynames = nullptr;
}

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

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

const char **objVal_tDescriptor::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 *objVal_tDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *objVal_tDescriptor::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[] = {
        "intval",
        "sintval",
        "int64val",
        "sint64val",
        "strval",
        "floatval",
        "doubleval",
    };
    return (field>=0 && field<7) ? fieldNames[field] : nullptr;
}

int objVal_tDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='i' && strcmp(fieldName, "intval")==0) return base+0;
    if (fieldName[0]=='s' && strcmp(fieldName, "sintval")==0) return base+1;
    if (fieldName[0]=='i' && strcmp(fieldName, "int64val")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "sint64val")==0) return base+3;
    if (fieldName[0]=='s' && strcmp(fieldName, "strval")==0) return base+4;
    if (fieldName[0]=='f' && strcmp(fieldName, "floatval")==0) return base+5;
    if (fieldName[0]=='d' && strcmp(fieldName, "doubleval")==0) return base+6;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *objVal_tDescriptor::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[] = {
        "uint32",
        "int32",
        "uint64",
        "int64",
        "string",
        "float",
        "double",
    };
    return (field>=0 && field<7) ? fieldTypeStrings[field] : nullptr;
}

const char **objVal_tDescriptor::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 *objVal_tDescriptor::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 objVal_tDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    objVal_t *pp = (objVal_t *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string objVal_tDescriptor::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();
    }
    objVal_t *pp = (objVal_t *)object; (void)pp;
    switch (field) {
        case 0: return ulong2string(pp->intval);
        case 1: return long2string(pp->sintval);
        case 2: return uint642string(pp->int64val);
        case 3: return int642string(pp->sint64val);
        case 4: return oppstring2string(pp->strval);
        case 5: return double2string(pp->floatval);
        case 6: return double2string(pp->doubleval);
        default: return "";
    }
}

bool objVal_tDescriptor::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();
    }
    objVal_t *pp = (objVal_t *)object; (void)pp;
    switch (field) {
        case 0: pp->intval = string2ulong(value); return true;
        case 1: pp->sintval = string2long(value); return true;
        case 2: pp->int64val = string2uint64(value); return true;
        case 3: pp->sint64val = string2int64(value); return true;
        case 4: pp->strval = (value); return true;
        case 5: pp->floatval = string2double(value); return true;
        case 6: pp->doubleval = string2double(value); return true;
        default: return false;
    }
}

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

EXECUTE_ON_STARTUP(
    omnetpp::cEnum *e = omnetpp::cEnum::find("authTypes_t");
    if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("authTypes_t"));
    e->insert(AUTH_NONE, "AUTH_NONE");
    e->insert(AUTH_PASSWD, "AUTH_PASSWD");
    e->insert(AUTH_SSHRSA, "AUTH_SSHRSA");
    e->insert(AUTH_SSHDSA, "AUTH_SSHDSA");
);

EXECUTE_ON_STARTUP(
    omnetpp::cEnum *e = omnetpp::cEnum::find("resultVal_t");
    if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("resultVal_t"));
    e->insert(R_CLASSNOTFOUND, "R_CLASSNOTFOUND");
    e->insert(R_OBJBADINST, "R_OBJBADINST");
    e->insert(R_OBJNOTFOUND, "R_OBJNOTFOUND");
    e->insert(R_OS_ERR, "R_OS_ERR");
    e->insert(R_FAIL, "R_FAIL");
    e->insert(R_SUCCESS, "R_SUCCESS");
    e->insert(R_SYNC_UNIMP, "R_SYNC_UNIMP");
    e->insert(R_FILTER_FALSE, "R_FILTER_FALSE");
    e->insert(R_FILTER_MIXED, "R_FILTER_MIXED");
);

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

authValue_t::authValue_t()
{
}

void __doPacking(omnetpp::cCommBuffer *b, const authValue_t& a)
{
    doParsimPacking(b,a.authName);
    doParsimPacking(b,a.authPassword);
    doParsimPacking(b,a.authOther);
}

void __doUnpacking(omnetpp::cCommBuffer *b, authValue_t& a)
{
    doParsimUnpacking(b,a.authName);
    doParsimUnpacking(b,a.authPassword);
    doParsimUnpacking(b,a.authOther);
}

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

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

authValue_tDescriptor::authValue_tDescriptor() : omnetpp::cClassDescriptor("authValue_t", "")
{
    propertynames = nullptr;
}

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

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

const char **authValue_tDescriptor::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 *authValue_tDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *authValue_tDescriptor::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[] = {
        "authName",
        "authPassword",
        "authOther",
    };
    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
}

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

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

const char **authValue_tDescriptor::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 *authValue_tDescriptor::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 authValue_tDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    authValue_t *pp = (authValue_t *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string authValue_tDescriptor::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();
    }
    authValue_t *pp = (authValue_t *)object; (void)pp;
    switch (field) {
        case 0: return oppstring2string(pp->authName);
        case 1: return oppstring2string(pp->authPassword);
        case 2: return oppstring2string(pp->authOther);
        default: return "";
    }
}

bool authValue_tDescriptor::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();
    }
    authValue_t *pp = (authValue_t *)object; (void)pp;
    switch (field) {
        case 0: pp->authName = (value); return true;
        case 1: pp->authPassword = (value); return true;
        case 2: pp->authOther = (value); return true;
        default: return false;
    }
}

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

result_t::result_t()
{
    this->resultValue = 0;
}

void __doPacking(omnetpp::cCommBuffer *b, const result_t& a)
{
    doParsimPacking(b,a.resultReason);
    doParsimPacking(b,a.resultValue);
}

void __doUnpacking(omnetpp::cCommBuffer *b, result_t& a)
{
    doParsimUnpacking(b,a.resultReason);
    doParsimUnpacking(b,a.resultValue);
}

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

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

result_tDescriptor::result_tDescriptor() : omnetpp::cClassDescriptor("result_t", "")
{
    propertynames = nullptr;
}

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

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

const char **result_tDescriptor::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 *result_tDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

const char *result_tDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    static const char *fieldTypeStrings[] = {
        "string",
        "int32",
    };
    return (field>=0 && field<2) ? fieldTypeStrings[field] : nullptr;
}

const char **result_tDescriptor::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 *result_tDescriptor::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 result_tDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    result_t *pp = (result_t *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string result_tDescriptor::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();
    }
    result_t *pp = (result_t *)object; (void)pp;
    switch (field) {
        case 0: return oppstring2string(pp->resultReason);
        case 1: return long2string(pp->resultValue);
        default: return "";
    }
}

bool result_tDescriptor::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();
    }
    result_t *pp = (result_t *)object; (void)pp;
    switch (field) {
        case 0: pp->resultReason = (value); return true;
        case 1: pp->resultValue = string2long(value); return true;
        default: return false;
    }
}

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

auth_t::auth_t()
{
    this->authType = 0;
}

void __doPacking(omnetpp::cCommBuffer *b, const auth_t& a)
{
    doParsimPacking(b,a.authType);
    doParsimPacking(b,a.authValue);
}

void __doUnpacking(omnetpp::cCommBuffer *b, auth_t& a)
{
    doParsimUnpacking(b,a.authType);
    doParsimUnpacking(b,a.authValue);
}

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

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

auth_tDescriptor::auth_tDescriptor() : omnetpp::cClassDescriptor("auth_t", "")
{
    propertynames = nullptr;
}

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

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

const char **auth_tDescriptor::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 *auth_tDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

const char *auth_tDescriptor::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 char",
        "authValue_t",
    };
    return (field>=0 && field<2) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string auth_tDescriptor::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();
    }
    auth_t *pp = (auth_t *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->authType, "authTypes_t");
        case 1: {std::stringstream out; out << pp->authValue; return out.str();}
        default: return "";
    }
}

bool auth_tDescriptor::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();
    }
    auth_t *pp = (auth_t *)object; (void)pp;
    switch (field) {
        case 0: pp->authType = (authTypes_t)string2enum(value, "authTypes_t"); return true;
        default: return false;
    }
}

const char *auth_tDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 1: return omnetpp::opp_typename(typeid(authValue_t));
        default: return nullptr;
    };
}

void *auth_tDescriptor::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();
    }
    auth_t *pp = (auth_t *)object; (void)pp;
    switch (field) {
        case 1: return (void *)(&pp->authValue); break;
        default: return nullptr;
    }
}

naming_t::naming_t()
{
}

void __doPacking(omnetpp::cCommBuffer *b, const naming_t& a)
{
    doParsimPacking(b,a.AEInst);
    doParsimPacking(b,a.AEName);
    doParsimPacking(b,a.ApInst);
    doParsimPacking(b,a.ApName);
}

void __doUnpacking(omnetpp::cCommBuffer *b, naming_t& a)
{
    doParsimUnpacking(b,a.AEInst);
    doParsimUnpacking(b,a.AEName);
    doParsimUnpacking(b,a.ApInst);
    doParsimUnpacking(b,a.ApName);
}

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

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

naming_tDescriptor::naming_tDescriptor() : omnetpp::cClassDescriptor("naming_t", "")
{
    propertynames = nullptr;
}

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

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

const char **naming_tDescriptor::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 *naming_tDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *naming_tDescriptor::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[] = {
        "AEInst",
        "AEName",
        "ApInst",
        "ApName",
    };
    return (field>=0 && field<4) ? fieldNames[field] : nullptr;
}

int naming_tDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='A' && strcmp(fieldName, "AEInst")==0) return base+0;
    if (fieldName[0]=='A' && strcmp(fieldName, "AEName")==0) return base+1;
    if (fieldName[0]=='A' && strcmp(fieldName, "ApInst")==0) return base+2;
    if (fieldName[0]=='A' && strcmp(fieldName, "ApName")==0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

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

const char **naming_tDescriptor::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 *naming_tDescriptor::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 naming_tDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    naming_t *pp = (naming_t *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string naming_tDescriptor::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();
    }
    naming_t *pp = (naming_t *)object; (void)pp;
    switch (field) {
        case 0: return oppstring2string(pp->AEInst);
        case 1: return oppstring2string(pp->AEName);
        case 2: return oppstring2string(pp->ApInst);
        case 3: return oppstring2string(pp->ApName);
        default: return "";
    }
}

bool naming_tDescriptor::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();
    }
    naming_t *pp = (naming_t *)object; (void)pp;
    switch (field) {
        case 0: pp->AEInst = (value); return true;
        case 1: pp->AEName = (value); return true;
        case 2: pp->ApInst = (value); return true;
        case 3: pp->ApName = (value); return true;
        default: return false;
    }
}

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

object_t::object_t()
{
    this->objectInstance = 0;
}

void __doPacking(omnetpp::cCommBuffer *b, const object_t& a)
{
    doParsimPacking(b,a.objectClass);
    doParsimPacking(b,a.objectName);
    doParsimPacking(b,a.objectInstance);
    doParsimPacking(b,a.objectVal);
}

void __doUnpacking(omnetpp::cCommBuffer *b, object_t& a)
{
    doParsimUnpacking(b,a.objectClass);
    doParsimUnpacking(b,a.objectName);
    doParsimUnpacking(b,a.objectInstance);
    doParsimUnpacking(b,a.objectVal);
}

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

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

object_tDescriptor::object_tDescriptor() : omnetpp::cClassDescriptor("object_t", "")
{
    propertynames = nullptr;
}

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

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

const char **object_tDescriptor::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 *object_tDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *object_tDescriptor::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[] = {
        "objectClass",
        "objectName",
        "objectInstance",
        "objectVal",
    };
    return (field>=0 && field<4) ? fieldNames[field] : nullptr;
}

int object_tDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectClass")==0) return base+0;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectName")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectInstance")==0) return base+2;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectVal")==0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *object_tDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    static const char *fieldTypeStrings[] = {
        "string",
        "string",
        "int",
        "ObjectPtr",
    };
    return (field>=0 && field<4) ? fieldTypeStrings[field] : nullptr;
}

const char **object_tDescriptor::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 *object_tDescriptor::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 object_tDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    object_t *pp = (object_t *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string object_tDescriptor::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();
    }
    object_t *pp = (object_t *)object; (void)pp;
    switch (field) {
        case 0: return oppstring2string(pp->objectClass);
        case 1: return oppstring2string(pp->objectName);
        case 2: return long2string(pp->objectInstance);
        case 3: {std::stringstream out; out << pp->objectVal; return out.str();}
        default: return "";
    }
}

bool object_tDescriptor::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();
    }
    object_t *pp = (object_t *)object; (void)pp;
    switch (field) {
        case 0: pp->objectClass = (value); return true;
        case 1: pp->objectName = (value); return true;
        case 2: pp->objectInstance = string2long(value); return true;
        default: return false;
    }
}

const char *object_tDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 3: return omnetpp::opp_typename(typeid(ObjectPtr));
        default: return nullptr;
    };
}

void *object_tDescriptor::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();
    }
    object_t *pp = (object_t *)object; (void)pp;
    switch (field) {
        case 3: return (void *)(&pp->objectVal); break;
        default: return nullptr;
    }
}

EXECUTE_ON_STARTUP(
    omnetpp::cEnum *e = omnetpp::cEnum::find("headerBitLengths");
    if (!e) omnetpp::enums.getInstance()->add(e = new omnetpp::cEnum("headerBitLengths"));
    e->insert(hdrInt32, "hdrInt32");
    e->insert(hdrFiltr, "hdrFiltr");
    e->insert(hdrResult, "hdrResult");
    e->insert(hdrAuth, "hdrAuth");
    e->insert(hdrNaming, "hdrNaming");
);

Register_Class(CDAPMessage);

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

    this->headerBitLength = 160;
    this->opCode = 0;
    this->invokeID = 0;
}

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

CDAPMessage::~CDAPMessage()
{
}

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

void CDAPMessage::copy(const CDAPMessage& other)
{
    this->displayString = other.displayString;
    this->headerBitLength = other.headerBitLength;
    this->srcAddr = other.srcAddr;
    this->dstAddr = other.dstAddr;
    this->opCode = other.opCode;
    this->invokeID = other.invokeID;
}

void CDAPMessage::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::omnetpp::cPacket::parsimPack(b);
    doParsimPacking(b,this->displayString);
    doParsimPacking(b,this->headerBitLength);
    doParsimPacking(b,this->srcAddr);
    doParsimPacking(b,this->dstAddr);
    doParsimPacking(b,this->opCode);
    doParsimPacking(b,this->invokeID);
}

void CDAPMessage::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::omnetpp::cPacket::parsimUnpack(b);
    doParsimUnpacking(b,this->displayString);
    doParsimUnpacking(b,this->headerBitLength);
    doParsimUnpacking(b,this->srcAddr);
    doParsimUnpacking(b,this->dstAddr);
    doParsimUnpacking(b,this->opCode);
    doParsimUnpacking(b,this->invokeID);
}

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

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

unsigned int CDAPMessage::getHeaderBitLength() const
{
    return this->headerBitLength;
}

void CDAPMessage::setHeaderBitLength(unsigned int headerBitLength)
{
    this->headerBitLength = headerBitLength;
}

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

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

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

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

int32_t CDAPMessage::getOpCode() const
{
    return this->opCode;
}

void CDAPMessage::setOpCode(int32_t opCode)
{
    this->opCode = opCode;
}

int32_t CDAPMessage::getInvokeID() const
{
    return this->invokeID;
}

void CDAPMessage::setInvokeID(int32_t invokeID)
{
    this->invokeID = invokeID;
}

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

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

CDAPMessageDescriptor::CDAPMessageDescriptor() : omnetpp::cClassDescriptor("CDAPMessage", "omnetpp::cPacket")
{
    propertynames = nullptr;
}

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

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

const char **CDAPMessageDescriptor::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 *CDAPMessageDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAPMessageDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    static const char *fieldNames[] = {
        "displayString",
        "headerBitLength",
        "srcAddr",
        "dstAddr",
        "opCode",
        "invokeID",
    };
    return (field>=0 && field<6) ? fieldNames[field] : nullptr;
}

int CDAPMessageDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='d' && strcmp(fieldName, "displayString")==0) return base+0;
    if (fieldName[0]=='h' && strcmp(fieldName, "headerBitLength")==0) return base+1;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcAddr")==0) return base+2;
    if (fieldName[0]=='d' && strcmp(fieldName, "dstAddr")==0) return base+3;
    if (fieldName[0]=='o' && strcmp(fieldName, "opCode")==0) return base+4;
    if (fieldName[0]=='i' && strcmp(fieldName, "invokeID")==0) return base+5;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

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

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

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

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

std::string CDAPMessageDescriptor::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();
    }
    CDAPMessage *pp = (CDAPMessage *)object; (void)pp;
    switch (field) {
        case 0: return oppstring2string(pp->getDisplayString());
        case 1: return ulong2string(pp->getHeaderBitLength());
        case 2: {std::stringstream out; out << pp->getSrcAddr(); return out.str();}
        case 3: {std::stringstream out; out << pp->getDstAddr(); return out.str();}
        case 4: return enum2string(pp->getOpCode(), "opCode_t");
        case 5: return long2string(pp->getInvokeID());
        default: return "";
    }
}

bool CDAPMessageDescriptor::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();
    }
    CDAPMessage *pp = (CDAPMessage *)object; (void)pp;
    switch (field) {
        case 0: pp->setDisplayString((value)); return true;
        case 1: pp->setHeaderBitLength(string2ulong(value)); return true;
        case 4: pp->setOpCode((opCode_t)string2enum(value, "opCode_t")); return true;
        case 5: pp->setInvokeID(string2long(value)); return true;
        default: return false;
    }
}

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

void *CDAPMessageDescriptor::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();
    }
    CDAPMessage *pp = (CDAPMessage *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getSrcAddr()); break;
        case 3: return (void *)(&pp->getDstAddr()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Connect);

CDAP_M_Connect::CDAP_M_Connect(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#0066CC,#0066CC,0");
    this->setOpCode(M_CONNECT);
    this->setHeaderBitLength((2+3)*hdrInt32 + hdrAuth + 2*hdrNaming);

    this->flags = 0;
    this->version = 0;
    this->absSyntax = 0;
}

CDAP_M_Connect::CDAP_M_Connect(const CDAP_M_Connect& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Connect::~CDAP_M_Connect()
{
}

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

void CDAP_M_Connect::copy(const CDAP_M_Connect& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->absSyntax = other.absSyntax;
    this->auth = other.auth;
    this->src = other.src;
    this->dst = other.dst;
}

void CDAP_M_Connect::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->absSyntax);
    doParsimPacking(b,this->auth);
    doParsimPacking(b,this->src);
    doParsimPacking(b,this->dst);
}

void CDAP_M_Connect::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->absSyntax);
    doParsimUnpacking(b,this->auth);
    doParsimUnpacking(b,this->src);
    doParsimUnpacking(b,this->dst);
}

int32_t CDAP_M_Connect::getFlags() const
{
    return this->flags;
}

void CDAP_M_Connect::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Connect::getVersion() const
{
    return this->version;
}

void CDAP_M_Connect::setVersion(int32_t version)
{
    this->version = version;
}

int32_t CDAP_M_Connect::getAbsSyntax() const
{
    return this->absSyntax;
}

void CDAP_M_Connect::setAbsSyntax(int32_t absSyntax)
{
    this->absSyntax = absSyntax;
}

auth_t& CDAP_M_Connect::getAuth()
{
    return this->auth;
}

void CDAP_M_Connect::setAuth(const auth_t& auth)
{
    this->auth = auth;
}

APNamingInfo& CDAP_M_Connect::getSrc()
{
    return this->src;
}

void CDAP_M_Connect::setSrc(const APNamingInfo& src)
{
    this->src = src;
}

APNamingInfo& CDAP_M_Connect::getDst()
{
    return this->dst;
}

void CDAP_M_Connect::setDst(const APNamingInfo& dst)
{
    this->dst = dst;
}

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

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

CDAP_M_ConnectDescriptor::CDAP_M_ConnectDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Connect", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_ConnectDescriptor::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 *CDAP_M_ConnectDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_ConnectDescriptor::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[] = {
        "flags",
        "version",
        "absSyntax",
        "auth",
        "src",
        "dst",
    };
    return (field>=0 && field<6) ? fieldNames[field] : nullptr;
}

int CDAP_M_ConnectDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='a' && strcmp(fieldName, "absSyntax")==0) return base+2;
    if (fieldName[0]=='a' && strcmp(fieldName, "auth")==0) return base+3;
    if (fieldName[0]=='s' && strcmp(fieldName, "src")==0) return base+4;
    if (fieldName[0]=='d' && strcmp(fieldName, "dst")==0) return base+5;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

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

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

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

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

std::string CDAP_M_ConnectDescriptor::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();
    }
    CDAP_M_Connect *pp = (CDAP_M_Connect *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: return enum2string(pp->getAbsSyntax(), "absSyntax_t");
        case 3: {std::stringstream out; out << pp->getAuth(); return out.str();}
        case 4: {std::stringstream out; out << pp->getSrc(); return out.str();}
        case 5: {std::stringstream out; out << pp->getDst(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_ConnectDescriptor::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();
    }
    CDAP_M_Connect *pp = (CDAP_M_Connect *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 2: pp->setAbsSyntax((absSyntax_t)string2enum(value, "absSyntax_t")); return true;
        default: return false;
    }
}

const char *CDAP_M_ConnectDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 3: return omnetpp::opp_typename(typeid(auth_t));
        case 4: return omnetpp::opp_typename(typeid(APNamingInfo));
        case 5: return omnetpp::opp_typename(typeid(APNamingInfo));
        default: return nullptr;
    };
}

void *CDAP_M_ConnectDescriptor::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();
    }
    CDAP_M_Connect *pp = (CDAP_M_Connect *)object; (void)pp;
    switch (field) {
        case 3: return (void *)(&pp->getAuth()); break;
        case 4: return (void *)(&pp->getSrc()); break;
        case 5: return (void *)(&pp->getDst()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Connect_R);

CDAP_M_Connect_R::CDAP_M_Connect_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#0099FF,#0099FF,0");
    this->setOpCode(M_CONNECT_R);
    this->setHeaderBitLength((2+3)*hdrInt32 + hdrAuth + 2*hdrNaming + hdrResult);

    this->flags = 0;
    this->version = 0;
    this->absSyntax = 0;
}

CDAP_M_Connect_R::CDAP_M_Connect_R(const CDAP_M_Connect_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Connect_R::~CDAP_M_Connect_R()
{
}

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

void CDAP_M_Connect_R::copy(const CDAP_M_Connect_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->absSyntax = other.absSyntax;
    this->result = other.result;
    this->auth = other.auth;
    this->src = other.src;
    this->dst = other.dst;
}

void CDAP_M_Connect_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->absSyntax);
    doParsimPacking(b,this->result);
    doParsimPacking(b,this->auth);
    doParsimPacking(b,this->src);
    doParsimPacking(b,this->dst);
}

void CDAP_M_Connect_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->absSyntax);
    doParsimUnpacking(b,this->result);
    doParsimUnpacking(b,this->auth);
    doParsimUnpacking(b,this->src);
    doParsimUnpacking(b,this->dst);
}

int32_t CDAP_M_Connect_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_Connect_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Connect_R::getVersion() const
{
    return this->version;
}

void CDAP_M_Connect_R::setVersion(int32_t version)
{
    this->version = version;
}

int32_t CDAP_M_Connect_R::getAbsSyntax() const
{
    return this->absSyntax;
}

void CDAP_M_Connect_R::setAbsSyntax(int32_t absSyntax)
{
    this->absSyntax = absSyntax;
}

result_t& CDAP_M_Connect_R::getResult()
{
    return this->result;
}

void CDAP_M_Connect_R::setResult(const result_t& result)
{
    this->result = result;
}

auth_t& CDAP_M_Connect_R::getAuth()
{
    return this->auth;
}

void CDAP_M_Connect_R::setAuth(const auth_t& auth)
{
    this->auth = auth;
}

APNamingInfo& CDAP_M_Connect_R::getSrc()
{
    return this->src;
}

void CDAP_M_Connect_R::setSrc(const APNamingInfo& src)
{
    this->src = src;
}

APNamingInfo& CDAP_M_Connect_R::getDst()
{
    return this->dst;
}

void CDAP_M_Connect_R::setDst(const APNamingInfo& dst)
{
    this->dst = dst;
}

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

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

CDAP_M_Connect_RDescriptor::CDAP_M_Connect_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Connect_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_Connect_RDescriptor::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 *CDAP_M_Connect_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_Connect_RDescriptor::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[] = {
        "flags",
        "version",
        "absSyntax",
        "result",
        "auth",
        "src",
        "dst",
    };
    return (field>=0 && field<7) ? fieldNames[field] : nullptr;
}

int CDAP_M_Connect_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='a' && strcmp(fieldName, "absSyntax")==0) return base+2;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+3;
    if (fieldName[0]=='a' && strcmp(fieldName, "auth")==0) return base+4;
    if (fieldName[0]=='s' && strcmp(fieldName, "src")==0) return base+5;
    if (fieldName[0]=='d' && strcmp(fieldName, "dst")==0) return base+6;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_Connect_RDescriptor::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[] = {
        "int32",
        "int32",
        "int32",
        "result_t",
        "auth_t",
        "APNamingInfo",
        "APNamingInfo",
    };
    return (field>=0 && field<7) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_Connect_RDescriptor::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();
    }
    CDAP_M_Connect_R *pp = (CDAP_M_Connect_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: return enum2string(pp->getAbsSyntax(), "absSyntax_t");
        case 3: {std::stringstream out; out << pp->getResult(); return out.str();}
        case 4: {std::stringstream out; out << pp->getAuth(); return out.str();}
        case 5: {std::stringstream out; out << pp->getSrc(); return out.str();}
        case 6: {std::stringstream out; out << pp->getDst(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_Connect_RDescriptor::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();
    }
    CDAP_M_Connect_R *pp = (CDAP_M_Connect_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 2: pp->setAbsSyntax((absSyntax_t)string2enum(value, "absSyntax_t")); return true;
        default: return false;
    }
}

const char *CDAP_M_Connect_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 3: return omnetpp::opp_typename(typeid(result_t));
        case 4: return omnetpp::opp_typename(typeid(auth_t));
        case 5: return omnetpp::opp_typename(typeid(APNamingInfo));
        case 6: return omnetpp::opp_typename(typeid(APNamingInfo));
        default: return nullptr;
    };
}

void *CDAP_M_Connect_RDescriptor::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();
    }
    CDAP_M_Connect_R *pp = (CDAP_M_Connect_R *)object; (void)pp;
    switch (field) {
        case 3: return (void *)(&pp->getResult()); break;
        case 4: return (void *)(&pp->getAuth()); break;
        case 5: return (void *)(&pp->getSrc()); break;
        case 6: return (void *)(&pp->getDst()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Release);

CDAP_M_Release::CDAP_M_Release(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#993399,#993399,0");
    this->setOpCode(M_RELEASE);
    this->setHeaderBitLength((2+2)*hdrInt32);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_Release::CDAP_M_Release(const CDAP_M_Release& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Release::~CDAP_M_Release()
{
}

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

void CDAP_M_Release::copy(const CDAP_M_Release& other)
{
    this->flags = other.flags;
    this->version = other.version;
}

void CDAP_M_Release::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
}

void CDAP_M_Release::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
}

int32_t CDAP_M_Release::getFlags() const
{
    return this->flags;
}

void CDAP_M_Release::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Release::getVersion() const
{
    return this->version;
}

void CDAP_M_Release::setVersion(int32_t version)
{
    this->version = version;
}

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

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

CDAP_M_ReleaseDescriptor::CDAP_M_ReleaseDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Release", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_ReleaseDescriptor::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 *CDAP_M_ReleaseDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

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

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

std::string CDAP_M_ReleaseDescriptor::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();
    }
    CDAP_M_Release *pp = (CDAP_M_Release *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        default: return "";
    }
}

bool CDAP_M_ReleaseDescriptor::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();
    }
    CDAP_M_Release *pp = (CDAP_M_Release *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        default: return false;
    }
}

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

Register_Class(CDAP_M_Release_R);

CDAP_M_Release_R::CDAP_M_Release_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#9966CC,#9966CC,0");
    this->setOpCode(M_RELEASE_R);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_Release_R::CDAP_M_Release_R(const CDAP_M_Release_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Release_R::~CDAP_M_Release_R()
{
}

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

void CDAP_M_Release_R::copy(const CDAP_M_Release_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->result = other.result;
}

void CDAP_M_Release_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->result);
}

void CDAP_M_Release_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_Release_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_Release_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Release_R::getVersion() const
{
    return this->version;
}

void CDAP_M_Release_R::setVersion(int32_t version)
{
    this->version = version;
}

result_t& CDAP_M_Release_R::getResult()
{
    return this->result;
}

void CDAP_M_Release_R::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_Release_RDescriptor::CDAP_M_Release_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Release_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_Release_RDescriptor::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 *CDAP_M_Release_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_Release_RDescriptor::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[] = {
        "flags",
        "version",
        "result",
    };
    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
}

int CDAP_M_Release_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

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

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

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

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

std::string CDAP_M_Release_RDescriptor::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();
    }
    CDAP_M_Release_R *pp = (CDAP_M_Release_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_Release_RDescriptor::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();
    }
    CDAP_M_Release_R *pp = (CDAP_M_Release_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        default: return false;
    }
}

const char *CDAP_M_Release_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_Release_RDescriptor::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();
    }
    CDAP_M_Release_R *pp = (CDAP_M_Release_R *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Create);

CDAP_M_Create::CDAP_M_Create(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#FFEE00,#FFEE00,0");
    this->setOpCode(M_CREATE);
    this->setHeaderBitLength((2+3)*hdrInt32 + hdrFiltr);

    this->flags = 0;
    this->version = 0;
    this->scope = 0;
}

CDAP_M_Create::CDAP_M_Create(const CDAP_M_Create& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Create::~CDAP_M_Create()
{
}

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

void CDAP_M_Create::copy(const CDAP_M_Create& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->scope = other.scope;
    this->filter = other.filter;
}

void CDAP_M_Create::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->scope);
    doParsimPacking(b,this->filter);
}

void CDAP_M_Create::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->scope);
    doParsimUnpacking(b,this->filter);
}

int32_t CDAP_M_Create::getFlags() const
{
    return this->flags;
}

void CDAP_M_Create::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Create::getVersion() const
{
    return this->version;
}

void CDAP_M_Create::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Create::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Create::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

int32_t CDAP_M_Create::getScope() const
{
    return this->scope;
}

void CDAP_M_Create::setScope(int32_t scope)
{
    this->scope = scope;
}

const char * CDAP_M_Create::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Create::setFilter(const char * filter)
{
    this->filter = filter;
}

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

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

CDAP_M_CreateDescriptor::CDAP_M_CreateDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Create", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_CreateDescriptor::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 *CDAP_M_CreateDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_CreateDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "scope",
        "filter",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_CreateDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "scope")==0) return base+3;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_CreateDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "int32",
        "string",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_CreateDescriptor::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();
    }
    CDAP_M_Create *pp = (CDAP_M_Create *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return long2string(pp->getScope());
        case 4: return oppstring2string(pp->getFilter());
        default: return "";
    }
}

bool CDAP_M_CreateDescriptor::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();
    }
    CDAP_M_Create *pp = (CDAP_M_Create *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setScope(string2long(value)); return true;
        case 4: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_CreateDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        default: return nullptr;
    };
}

void *CDAP_M_CreateDescriptor::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();
    }
    CDAP_M_Create *pp = (CDAP_M_Create *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Create_R);

CDAP_M_Create_R::CDAP_M_Create_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#FFFF66,#FFFF66,0");
    this->setOpCode(M_CREATE_R);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult + hdrFiltr);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_Create_R::CDAP_M_Create_R(const CDAP_M_Create_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Create_R::~CDAP_M_Create_R()
{
}

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

void CDAP_M_Create_R::copy(const CDAP_M_Create_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->filter = other.filter;
    this->result = other.result;
}

void CDAP_M_Create_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->filter);
    doParsimPacking(b,this->result);
}

void CDAP_M_Create_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->filter);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_Create_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_Create_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Create_R::getVersion() const
{
    return this->version;
}

void CDAP_M_Create_R::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Create_R::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Create_R::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

const char * CDAP_M_Create_R::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Create_R::setFilter(const char * filter)
{
    this->filter = filter;
}

result_t& CDAP_M_Create_R::getResult()
{
    return this->result;
}

void CDAP_M_Create_R::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_Create_RDescriptor::CDAP_M_Create_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Create_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_Create_RDescriptor::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 *CDAP_M_Create_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_Create_RDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "filter",
        "result",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_Create_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+3;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_Create_RDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "string",
        "result_t",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_Create_RDescriptor::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();
    }
    CDAP_M_Create_R *pp = (CDAP_M_Create_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return oppstring2string(pp->getFilter());
        case 4: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_Create_RDescriptor::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();
    }
    CDAP_M_Create_R *pp = (CDAP_M_Create_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_Create_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        case 4: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_Create_RDescriptor::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();
    }
    CDAP_M_Create_R *pp = (CDAP_M_Create_R *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        case 4: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Delete);

CDAP_M_Delete::CDAP_M_Delete(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#CC6633,#CC6633,0");
    this->setOpCode(M_DELETE);
    this->setHeaderBitLength((2+3)*hdrInt32 + hdrFiltr);

    this->flags = 0;
    this->version = 0;
    this->scope = 0;
}

CDAP_M_Delete::CDAP_M_Delete(const CDAP_M_Delete& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Delete::~CDAP_M_Delete()
{
}

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

void CDAP_M_Delete::copy(const CDAP_M_Delete& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->scope = other.scope;
    this->filter = other.filter;
}

void CDAP_M_Delete::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->scope);
    doParsimPacking(b,this->filter);
}

void CDAP_M_Delete::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->scope);
    doParsimUnpacking(b,this->filter);
}

int32_t CDAP_M_Delete::getFlags() const
{
    return this->flags;
}

void CDAP_M_Delete::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Delete::getVersion() const
{
    return this->version;
}

void CDAP_M_Delete::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Delete::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Delete::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

int32_t CDAP_M_Delete::getScope() const
{
    return this->scope;
}

void CDAP_M_Delete::setScope(int32_t scope)
{
    this->scope = scope;
}

const char * CDAP_M_Delete::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Delete::setFilter(const char * filter)
{
    this->filter = filter;
}

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

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

CDAP_M_DeleteDescriptor::CDAP_M_DeleteDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Delete", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_DeleteDescriptor::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 *CDAP_M_DeleteDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_DeleteDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "scope",
        "filter",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_DeleteDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "scope")==0) return base+3;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_DeleteDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "int32",
        "string",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_DeleteDescriptor::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();
    }
    CDAP_M_Delete *pp = (CDAP_M_Delete *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return long2string(pp->getScope());
        case 4: return oppstring2string(pp->getFilter());
        default: return "";
    }
}

bool CDAP_M_DeleteDescriptor::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();
    }
    CDAP_M_Delete *pp = (CDAP_M_Delete *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setScope(string2long(value)); return true;
        case 4: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_DeleteDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        default: return nullptr;
    };
}

void *CDAP_M_DeleteDescriptor::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();
    }
    CDAP_M_Delete *pp = (CDAP_M_Delete *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Delete_R);

CDAP_M_Delete_R::CDAP_M_Delete_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#CC9966,#CC9966,0");
    this->setOpCode(M_DELETE_R);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult + hdrFiltr);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_Delete_R::CDAP_M_Delete_R(const CDAP_M_Delete_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Delete_R::~CDAP_M_Delete_R()
{
}

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

void CDAP_M_Delete_R::copy(const CDAP_M_Delete_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->filter = other.filter;
    this->result = other.result;
}

void CDAP_M_Delete_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->filter);
    doParsimPacking(b,this->result);
}

void CDAP_M_Delete_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->filter);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_Delete_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_Delete_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Delete_R::getVersion() const
{
    return this->version;
}

void CDAP_M_Delete_R::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Delete_R::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Delete_R::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

const char * CDAP_M_Delete_R::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Delete_R::setFilter(const char * filter)
{
    this->filter = filter;
}

result_t& CDAP_M_Delete_R::getResult()
{
    return this->result;
}

void CDAP_M_Delete_R::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_Delete_RDescriptor::CDAP_M_Delete_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Delete_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_Delete_RDescriptor::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 *CDAP_M_Delete_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_Delete_RDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "filter",
        "result",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_Delete_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+3;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_Delete_RDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "string",
        "result_t",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_Delete_RDescriptor::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();
    }
    CDAP_M_Delete_R *pp = (CDAP_M_Delete_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return oppstring2string(pp->getFilter());
        case 4: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_Delete_RDescriptor::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();
    }
    CDAP_M_Delete_R *pp = (CDAP_M_Delete_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_Delete_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        case 4: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_Delete_RDescriptor::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();
    }
    CDAP_M_Delete_R *pp = (CDAP_M_Delete_R *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        case 4: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Read);

CDAP_M_Read::CDAP_M_Read(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#33CCCC,#33CCCC,0");
    this->setOpCode(M_READ);
    this->setHeaderBitLength((2+3)*hdrInt32 + hdrFiltr);

    this->flags = 0;
    this->version = 0;
    this->scope = 0;
}

CDAP_M_Read::CDAP_M_Read(const CDAP_M_Read& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Read::~CDAP_M_Read()
{
}

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

void CDAP_M_Read::copy(const CDAP_M_Read& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->scope = other.scope;
    this->filter = other.filter;
}

void CDAP_M_Read::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->scope);
    doParsimPacking(b,this->filter);
}

void CDAP_M_Read::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->scope);
    doParsimUnpacking(b,this->filter);
}

int32_t CDAP_M_Read::getFlags() const
{
    return this->flags;
}

void CDAP_M_Read::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Read::getVersion() const
{
    return this->version;
}

void CDAP_M_Read::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Read::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Read::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

int32_t CDAP_M_Read::getScope() const
{
    return this->scope;
}

void CDAP_M_Read::setScope(int32_t scope)
{
    this->scope = scope;
}

const char * CDAP_M_Read::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Read::setFilter(const char * filter)
{
    this->filter = filter;
}

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

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

CDAP_M_ReadDescriptor::CDAP_M_ReadDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Read", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_ReadDescriptor::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 *CDAP_M_ReadDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_ReadDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "scope",
        "filter",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_ReadDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "scope")==0) return base+3;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_ReadDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "int32",
        "string",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_ReadDescriptor::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();
    }
    CDAP_M_Read *pp = (CDAP_M_Read *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return long2string(pp->getScope());
        case 4: return oppstring2string(pp->getFilter());
        default: return "";
    }
}

bool CDAP_M_ReadDescriptor::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();
    }
    CDAP_M_Read *pp = (CDAP_M_Read *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setScope(string2long(value)); return true;
        case 4: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_ReadDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        default: return nullptr;
    };
}

void *CDAP_M_ReadDescriptor::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();
    }
    CDAP_M_Read *pp = (CDAP_M_Read *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Read_R);

CDAP_M_Read_R::CDAP_M_Read_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#33FFCC,#33FFCC,0");
    this->setOpCode(M_READ_R);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult + hdrFiltr);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_Read_R::CDAP_M_Read_R(const CDAP_M_Read_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Read_R::~CDAP_M_Read_R()
{
}

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

void CDAP_M_Read_R::copy(const CDAP_M_Read_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->filter = other.filter;
    this->result = other.result;
}

void CDAP_M_Read_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->filter);
    doParsimPacking(b,this->result);
}

void CDAP_M_Read_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->filter);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_Read_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_Read_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Read_R::getVersion() const
{
    return this->version;
}

void CDAP_M_Read_R::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Read_R::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Read_R::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

const char * CDAP_M_Read_R::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Read_R::setFilter(const char * filter)
{
    this->filter = filter;
}

result_t& CDAP_M_Read_R::getResult()
{
    return this->result;
}

void CDAP_M_Read_R::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_Read_RDescriptor::CDAP_M_Read_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Read_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_Read_RDescriptor::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 *CDAP_M_Read_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_Read_RDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "filter",
        "result",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_Read_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+3;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_Read_RDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "string",
        "result_t",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_Read_RDescriptor::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();
    }
    CDAP_M_Read_R *pp = (CDAP_M_Read_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return oppstring2string(pp->getFilter());
        case 4: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_Read_RDescriptor::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();
    }
    CDAP_M_Read_R *pp = (CDAP_M_Read_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_Read_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        case 4: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_Read_RDescriptor::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();
    }
    CDAP_M_Read_R *pp = (CDAP_M_Read_R *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        case 4: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_CancelRead);

CDAP_M_CancelRead::CDAP_M_CancelRead(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#333366,#333366,0");
    this->setOpCode(M_CANCELREAD);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_CancelRead::CDAP_M_CancelRead(const CDAP_M_CancelRead& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_CancelRead::~CDAP_M_CancelRead()
{
}

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

void CDAP_M_CancelRead::copy(const CDAP_M_CancelRead& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->result = other.result;
}

void CDAP_M_CancelRead::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->result);
}

void CDAP_M_CancelRead::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_CancelRead::getFlags() const
{
    return this->flags;
}

void CDAP_M_CancelRead::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_CancelRead::getVersion() const
{
    return this->version;
}

void CDAP_M_CancelRead::setVersion(int32_t version)
{
    this->version = version;
}

result_t& CDAP_M_CancelRead::getResult()
{
    return this->result;
}

void CDAP_M_CancelRead::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_CancelReadDescriptor::CDAP_M_CancelReadDescriptor() : omnetpp::cClassDescriptor("CDAP_M_CancelRead", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_CancelReadDescriptor::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 *CDAP_M_CancelReadDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_CancelReadDescriptor::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[] = {
        "flags",
        "version",
        "result",
    };
    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
}

int CDAP_M_CancelReadDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

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

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

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

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

std::string CDAP_M_CancelReadDescriptor::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();
    }
    CDAP_M_CancelRead *pp = (CDAP_M_CancelRead *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_CancelReadDescriptor::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();
    }
    CDAP_M_CancelRead *pp = (CDAP_M_CancelRead *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        default: return false;
    }
}

const char *CDAP_M_CancelReadDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_CancelReadDescriptor::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();
    }
    CDAP_M_CancelRead *pp = (CDAP_M_CancelRead *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_CancelRead_R);

CDAP_M_CancelRead_R::CDAP_M_CancelRead_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#333399,#333399,0");
    this->setOpCode(M_CANCELREAD_R);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_CancelRead_R::CDAP_M_CancelRead_R(const CDAP_M_CancelRead_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_CancelRead_R::~CDAP_M_CancelRead_R()
{
}

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

void CDAP_M_CancelRead_R::copy(const CDAP_M_CancelRead_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->result = other.result;
}

void CDAP_M_CancelRead_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->result);
}

void CDAP_M_CancelRead_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_CancelRead_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_CancelRead_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_CancelRead_R::getVersion() const
{
    return this->version;
}

void CDAP_M_CancelRead_R::setVersion(int32_t version)
{
    this->version = version;
}

result_t& CDAP_M_CancelRead_R::getResult()
{
    return this->result;
}

void CDAP_M_CancelRead_R::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_CancelRead_RDescriptor::CDAP_M_CancelRead_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_CancelRead_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_CancelRead_RDescriptor::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 *CDAP_M_CancelRead_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_CancelRead_RDescriptor::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[] = {
        "flags",
        "version",
        "result",
    };
    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
}

int CDAP_M_CancelRead_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

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

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

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

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

std::string CDAP_M_CancelRead_RDescriptor::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();
    }
    CDAP_M_CancelRead_R *pp = (CDAP_M_CancelRead_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_CancelRead_RDescriptor::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();
    }
    CDAP_M_CancelRead_R *pp = (CDAP_M_CancelRead_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        default: return false;
    }
}

const char *CDAP_M_CancelRead_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_CancelRead_RDescriptor::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();
    }
    CDAP_M_CancelRead_R *pp = (CDAP_M_CancelRead_R *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Write);

CDAP_M_Write::CDAP_M_Write(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#CC9900,#CC9900,0");
    this->setOpCode(M_WRITE);
    this->setHeaderBitLength((2+3)*hdrInt32 + hdrFiltr);

    this->flags = 0;
    this->version = 0;
    this->scope = 0;
}

CDAP_M_Write::CDAP_M_Write(const CDAP_M_Write& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Write::~CDAP_M_Write()
{
}

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

void CDAP_M_Write::copy(const CDAP_M_Write& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->scope = other.scope;
    this->filter = other.filter;
}

void CDAP_M_Write::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->scope);
    doParsimPacking(b,this->filter);
}

void CDAP_M_Write::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->scope);
    doParsimUnpacking(b,this->filter);
}

int32_t CDAP_M_Write::getFlags() const
{
    return this->flags;
}

void CDAP_M_Write::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Write::getVersion() const
{
    return this->version;
}

void CDAP_M_Write::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Write::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Write::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

int32_t CDAP_M_Write::getScope() const
{
    return this->scope;
}

void CDAP_M_Write::setScope(int32_t scope)
{
    this->scope = scope;
}

const char * CDAP_M_Write::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Write::setFilter(const char * filter)
{
    this->filter = filter;
}

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

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

CDAP_M_WriteDescriptor::CDAP_M_WriteDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Write", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_WriteDescriptor::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 *CDAP_M_WriteDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_WriteDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "scope",
        "filter",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_WriteDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "scope")==0) return base+3;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_WriteDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "int32",
        "string",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_WriteDescriptor::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();
    }
    CDAP_M_Write *pp = (CDAP_M_Write *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return long2string(pp->getScope());
        case 4: return oppstring2string(pp->getFilter());
        default: return "";
    }
}

bool CDAP_M_WriteDescriptor::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();
    }
    CDAP_M_Write *pp = (CDAP_M_Write *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setScope(string2long(value)); return true;
        case 4: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_WriteDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        default: return nullptr;
    };
}

void *CDAP_M_WriteDescriptor::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();
    }
    CDAP_M_Write *pp = (CDAP_M_Write *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Write_R);

CDAP_M_Write_R::CDAP_M_Write_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#CC9933,#CC9933,0");
    this->setOpCode(M_WRITE_R);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult + hdrFiltr);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_Write_R::CDAP_M_Write_R(const CDAP_M_Write_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Write_R::~CDAP_M_Write_R()
{
}

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

void CDAP_M_Write_R::copy(const CDAP_M_Write_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->filter = other.filter;
    this->result = other.result;
}

void CDAP_M_Write_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->filter);
    doParsimPacking(b,this->result);
}

void CDAP_M_Write_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->filter);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_Write_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_Write_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Write_R::getVersion() const
{
    return this->version;
}

void CDAP_M_Write_R::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Write_R::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Write_R::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

const char * CDAP_M_Write_R::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Write_R::setFilter(const char * filter)
{
    this->filter = filter;
}

result_t& CDAP_M_Write_R::getResult()
{
    return this->result;
}

void CDAP_M_Write_R::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_Write_RDescriptor::CDAP_M_Write_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Write_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_Write_RDescriptor::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 *CDAP_M_Write_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_Write_RDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "filter",
        "result",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_Write_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+3;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_Write_RDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "string",
        "result_t",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_Write_RDescriptor::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();
    }
    CDAP_M_Write_R *pp = (CDAP_M_Write_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return oppstring2string(pp->getFilter());
        case 4: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_Write_RDescriptor::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();
    }
    CDAP_M_Write_R *pp = (CDAP_M_Write_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_Write_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        case 4: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_Write_RDescriptor::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();
    }
    CDAP_M_Write_R *pp = (CDAP_M_Write_R *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        case 4: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Start);

CDAP_M_Start::CDAP_M_Start(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#99CC00,#99CC00,0");
    this->setOpCode(M_START);
    this->setHeaderBitLength((2+3)*hdrInt32 + hdrFiltr);

    this->flags = 0;
    this->version = 0;
    this->scope = 0;
}

CDAP_M_Start::CDAP_M_Start(const CDAP_M_Start& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Start::~CDAP_M_Start()
{
}

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

void CDAP_M_Start::copy(const CDAP_M_Start& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->scope = other.scope;
    this->filter = other.filter;
}

void CDAP_M_Start::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->scope);
    doParsimPacking(b,this->filter);
}

void CDAP_M_Start::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->scope);
    doParsimUnpacking(b,this->filter);
}

int32_t CDAP_M_Start::getFlags() const
{
    return this->flags;
}

void CDAP_M_Start::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Start::getVersion() const
{
    return this->version;
}

void CDAP_M_Start::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Start::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Start::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

int32_t CDAP_M_Start::getScope() const
{
    return this->scope;
}

void CDAP_M_Start::setScope(int32_t scope)
{
    this->scope = scope;
}

const char * CDAP_M_Start::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Start::setFilter(const char * filter)
{
    this->filter = filter;
}

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

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

CDAP_M_StartDescriptor::CDAP_M_StartDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Start", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_StartDescriptor::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 *CDAP_M_StartDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_StartDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "scope",
        "filter",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_StartDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "scope")==0) return base+3;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_StartDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "int32",
        "string",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_StartDescriptor::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();
    }
    CDAP_M_Start *pp = (CDAP_M_Start *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return long2string(pp->getScope());
        case 4: return oppstring2string(pp->getFilter());
        default: return "";
    }
}

bool CDAP_M_StartDescriptor::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();
    }
    CDAP_M_Start *pp = (CDAP_M_Start *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setScope(string2long(value)); return true;
        case 4: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_StartDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        default: return nullptr;
    };
}

void *CDAP_M_StartDescriptor::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();
    }
    CDAP_M_Start *pp = (CDAP_M_Start *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Start_R);

CDAP_M_Start_R::CDAP_M_Start_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#99FF33,#99FF33,0");
    this->setOpCode(M_START_R);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult + hdrFiltr);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_Start_R::CDAP_M_Start_R(const CDAP_M_Start_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Start_R::~CDAP_M_Start_R()
{
}

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

void CDAP_M_Start_R::copy(const CDAP_M_Start_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->filter = other.filter;
    this->result = other.result;
}

void CDAP_M_Start_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->filter);
    doParsimPacking(b,this->result);
}

void CDAP_M_Start_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->filter);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_Start_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_Start_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Start_R::getVersion() const
{
    return this->version;
}

void CDAP_M_Start_R::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Start_R::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Start_R::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

const char * CDAP_M_Start_R::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Start_R::setFilter(const char * filter)
{
    this->filter = filter;
}

result_t& CDAP_M_Start_R::getResult()
{
    return this->result;
}

void CDAP_M_Start_R::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_Start_RDescriptor::CDAP_M_Start_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Start_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_Start_RDescriptor::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 *CDAP_M_Start_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_Start_RDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "filter",
        "result",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_Start_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+3;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_Start_RDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "string",
        "result_t",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_Start_RDescriptor::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();
    }
    CDAP_M_Start_R *pp = (CDAP_M_Start_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return oppstring2string(pp->getFilter());
        case 4: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_Start_RDescriptor::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();
    }
    CDAP_M_Start_R *pp = (CDAP_M_Start_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_Start_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        case 4: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_Start_RDescriptor::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();
    }
    CDAP_M_Start_R *pp = (CDAP_M_Start_R *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        case 4: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Stop);

CDAP_M_Stop::CDAP_M_Stop(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#FF3333,#FF3333,0");
    this->setOpCode(M_STOP);
    this->setHeaderBitLength((2+3)*hdrInt32 + hdrFiltr);

    this->flags = 0;
    this->version = 0;
    this->scope = 0;
}

CDAP_M_Stop::CDAP_M_Stop(const CDAP_M_Stop& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Stop::~CDAP_M_Stop()
{
}

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

void CDAP_M_Stop::copy(const CDAP_M_Stop& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->scope = other.scope;
    this->filter = other.filter;
}

void CDAP_M_Stop::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->scope);
    doParsimPacking(b,this->filter);
}

void CDAP_M_Stop::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->scope);
    doParsimUnpacking(b,this->filter);
}

int32_t CDAP_M_Stop::getFlags() const
{
    return this->flags;
}

void CDAP_M_Stop::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Stop::getVersion() const
{
    return this->version;
}

void CDAP_M_Stop::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Stop::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Stop::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

int32_t CDAP_M_Stop::getScope() const
{
    return this->scope;
}

void CDAP_M_Stop::setScope(int32_t scope)
{
    this->scope = scope;
}

const char * CDAP_M_Stop::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Stop::setFilter(const char * filter)
{
    this->filter = filter;
}

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

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

CDAP_M_StopDescriptor::CDAP_M_StopDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Stop", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_StopDescriptor::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 *CDAP_M_StopDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_StopDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "scope",
        "filter",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_StopDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "scope")==0) return base+3;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_StopDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "int32",
        "string",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_StopDescriptor::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();
    }
    CDAP_M_Stop *pp = (CDAP_M_Stop *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return long2string(pp->getScope());
        case 4: return oppstring2string(pp->getFilter());
        default: return "";
    }
}

bool CDAP_M_StopDescriptor::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();
    }
    CDAP_M_Stop *pp = (CDAP_M_Stop *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setScope(string2long(value)); return true;
        case 4: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_StopDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        default: return nullptr;
    };
}

void *CDAP_M_StopDescriptor::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();
    }
    CDAP_M_Stop *pp = (CDAP_M_Stop *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        default: return nullptr;
    }
}

Register_Class(CDAP_M_Stop_R);

CDAP_M_Stop_R::CDAP_M_Stop_R(const char *name, int kind) : ::CDAPMessage(name,kind)
{
    this->setDisplayString("b=15,15,oval,#FF6666,#FF6666,0");
    this->setOpCode(M_STOP_R);
    this->setHeaderBitLength((2+2)*hdrInt32 + hdrResult + hdrFiltr);

    this->flags = 0;
    this->version = 0;
}

CDAP_M_Stop_R::CDAP_M_Stop_R(const CDAP_M_Stop_R& other) : ::CDAPMessage(other)
{
    copy(other);
}

CDAP_M_Stop_R::~CDAP_M_Stop_R()
{
}

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

void CDAP_M_Stop_R::copy(const CDAP_M_Stop_R& other)
{
    this->flags = other.flags;
    this->version = other.version;
    this->objectItem = other.objectItem;
    this->filter = other.filter;
    this->result = other.result;
}

void CDAP_M_Stop_R::parsimPack(omnetpp::cCommBuffer *b) const
{
    ::CDAPMessage::parsimPack(b);
    doParsimPacking(b,this->flags);
    doParsimPacking(b,this->version);
    doParsimPacking(b,this->objectItem);
    doParsimPacking(b,this->filter);
    doParsimPacking(b,this->result);
}

void CDAP_M_Stop_R::parsimUnpack(omnetpp::cCommBuffer *b)
{
    ::CDAPMessage::parsimUnpack(b);
    doParsimUnpacking(b,this->flags);
    doParsimUnpacking(b,this->version);
    doParsimUnpacking(b,this->objectItem);
    doParsimUnpacking(b,this->filter);
    doParsimUnpacking(b,this->result);
}

int32_t CDAP_M_Stop_R::getFlags() const
{
    return this->flags;
}

void CDAP_M_Stop_R::setFlags(int32_t flags)
{
    this->flags = flags;
}

int32_t CDAP_M_Stop_R::getVersion() const
{
    return this->version;
}

void CDAP_M_Stop_R::setVersion(int32_t version)
{
    this->version = version;
}

object_t& CDAP_M_Stop_R::getObjectItem()
{
    return this->objectItem;
}

void CDAP_M_Stop_R::setObjectItem(const object_t& objectItem)
{
    this->objectItem = objectItem;
}

const char * CDAP_M_Stop_R::getFilter() const
{
    return this->filter.c_str();
}

void CDAP_M_Stop_R::setFilter(const char * filter)
{
    this->filter = filter;
}

result_t& CDAP_M_Stop_R::getResult()
{
    return this->result;
}

void CDAP_M_Stop_R::setResult(const result_t& result)
{
    this->result = result;
}

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

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

CDAP_M_Stop_RDescriptor::CDAP_M_Stop_RDescriptor() : omnetpp::cClassDescriptor("CDAP_M_Stop_R", "CDAPMessage")
{
    propertynames = nullptr;
}

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

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

const char **CDAP_M_Stop_RDescriptor::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 *CDAP_M_Stop_RDescriptor::getProperty(const char *propertyname) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *CDAP_M_Stop_RDescriptor::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[] = {
        "flags",
        "version",
        "objectItem",
        "filter",
        "result",
    };
    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
}

int CDAP_M_Stop_RDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "flags")==0) return base+0;
    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+1;
    if (fieldName[0]=='o' && strcmp(fieldName, "objectItem")==0) return base+2;
    if (fieldName[0]=='f' && strcmp(fieldName, "filter")==0) return base+3;
    if (fieldName[0]=='r' && strcmp(fieldName, "result")==0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CDAP_M_Stop_RDescriptor::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[] = {
        "int32",
        "int32",
        "object_t",
        "string",
        "result_t",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
}

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

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

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

std::string CDAP_M_Stop_RDescriptor::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();
    }
    CDAP_M_Stop_R *pp = (CDAP_M_Stop_R *)object; (void)pp;
    switch (field) {
        case 0: return enum2string(pp->getFlags(), "flagValues_t");
        case 1: return long2string(pp->getVersion());
        case 2: {std::stringstream out; out << pp->getObjectItem(); return out.str();}
        case 3: return oppstring2string(pp->getFilter());
        case 4: {std::stringstream out; out << pp->getResult(); return out.str();}
        default: return "";
    }
}

bool CDAP_M_Stop_RDescriptor::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();
    }
    CDAP_M_Stop_R *pp = (CDAP_M_Stop_R *)object; (void)pp;
    switch (field) {
        case 0: pp->setFlags((flagValues_t)string2enum(value, "flagValues_t")); return true;
        case 1: pp->setVersion(string2long(value)); return true;
        case 3: pp->setFilter((value)); return true;
        default: return false;
    }
}

const char *CDAP_M_Stop_RDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case 2: return omnetpp::opp_typename(typeid(object_t));
        case 4: return omnetpp::opp_typename(typeid(result_t));
        default: return nullptr;
    };
}

void *CDAP_M_Stop_RDescriptor::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();
    }
    CDAP_M_Stop_R *pp = (CDAP_M_Stop_R *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getObjectItem()); break;
        case 4: return (void *)(&pp->getResult()); break;
        default: return nullptr;
    }
}