//
// Generated file, do not edit! Created by nedtool 5.4 from sim_std.msg.
//

// Disable warnings about unused variables, empty switch stmts, etc:
#ifdef _MSC_VER
#  pragma warning(disable:4101)
#  pragma warning(disable:4065)
#endif

#if defined(__clang__)
#  pragma clang diagnostic ignored "-Wshadow"
#  pragma clang diagnostic ignored "-Wconversion"
#  pragma clang diagnostic ignored "-Wunused-parameter"
#  pragma clang diagnostic ignored "-Wc++98-compat"
#  pragma clang diagnostic ignored "-Wunreachable-code-break"
#  pragma clang diagnostic ignored "-Wold-style-cast"
#elif defined(__GNUC__)
#  pragma GCC diagnostic ignored "-Wshadow"
#  pragma GCC diagnostic ignored "-Wconversion"
#  pragma GCC diagnostic ignored "-Wunused-parameter"
#  pragma GCC diagnostic ignored "-Wold-style-cast"
#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
#  pragma GCC diagnostic ignored "-Wfloat-conversion"
#endif

#include <iostream>
#include <sstream>
#include <memory>
#include "sim_std_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

namespace {
template <class T> inline
typename std::enable_if<std::is_polymorphic<T>::value && std::is_base_of<omnetpp::cObject,T>::value, void *>::type
toVoidPtr(T* t)
{
    return (void *)(static_cast<const omnetpp::cObject *>(t));
}

template <class T> inline
typename std::enable_if<std::is_polymorphic<T>::value && !std::is_base_of<omnetpp::cObject,T>::value, void *>::type
toVoidPtr(T* t)
{
    return (void *)dynamic_cast<const void *>(t);
}

template <class T> inline
typename std::enable_if<!std::is_polymorphic<T>::value, void *>::type
toVoidPtr(T* t)
{
    return (void *)static_cast<const void *>(t);
}

}

namespace omnetpp {

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

// Template rule to generate operator<< for shared_ptr<T>
template<typename T>
inline std::ostream& operator<<(std::ostream& out,const std::shared_ptr<T>& t) { return out << t.get(); }

// 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;
}

class cObjectDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_className,
        FIELD_fullName,
        FIELD_fullPath,
        FIELD_info,
    };
  public:
    cObjectDescriptor();
    virtual ~cObjectDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cObjectDescriptor)

cObjectDescriptor::cObjectDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cObject)), "")
{
    propertynames = nullptr;
}

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

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

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

const char *cObjectDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "cogwheel";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cObjectDescriptor::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[] = {
        0,    // FIELD_className
        0,    // FIELD_fullName
        0,    // FIELD_fullPath
        0,    // FIELD_info
    };
    return (field >= 0 && field < 4) ? fieldTypeFlags[field] : 0;
}

const char *cObjectDescriptor::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[] = {
        "className",
        "fullName",
        "fullPath",
        "info",
    };
    return (field >= 0 && field < 4) ? fieldNames[field] : nullptr;
}

int cObjectDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "className") == 0) return base+0;
    if (fieldName[0] == 'f' && strcmp(fieldName, "fullName") == 0) return base+1;
    if (fieldName[0] == 'f' && strcmp(fieldName, "fullPath") == 0) return base+2;
    if (fieldName[0] == 'i' && strcmp(fieldName, "info") == 0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cObjectDescriptor::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",    // FIELD_className
        "string",    // FIELD_fullName
        "string",    // FIELD_fullPath
        "string",    // FIELD_info
    };
    return (field >= 0 && field < 4) ? fieldTypeStrings[field] : nullptr;
}

const char **cObjectDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_className: {
            static const char *names[] = { "group", "hint", "eventlog",  nullptr };
            return names;
        }
        case FIELD_fullName: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_fullPath: {
            static const char *names[] = { "group", "hint", "eventlog",  nullptr };
            return names;
        }
        case FIELD_info: {
            static const char *names[] = { "getter", "group", "hint", "eventlog",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cObjectDescriptor::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 FIELD_className:
            if (!strcmp(propertyname, "group")) return "base";
            if (!strcmp(propertyname, "hint")) return "C++ class name";
            if (!strcmp(propertyname, "eventlog")) return "skip";
            return nullptr;
        case FIELD_fullName:
            if (!strcmp(propertyname, "group")) return "base";
            if (!strcmp(propertyname, "hint")) return "If object is part of a module/gate vector: name with index";
            return nullptr;
        case FIELD_fullPath:
            if (!strcmp(propertyname, "group")) return "base";
            if (!strcmp(propertyname, "hint")) return "Hierarchical name, composed of full names of this object and its owners/parents";
            if (!strcmp(propertyname, "eventlog")) return "skip";
            return nullptr;
        case FIELD_info:
            if (!strcmp(propertyname, "getter")) return "str";
            if (!strcmp(propertyname, "group")) return "base";
            if (!strcmp(propertyname, "hint")) return "Text provided by the object's \"str()\" method";
            if (!strcmp(propertyname, "eventlog")) return "skip";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cObjectDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cObject *pp = (cObject *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cObjectDescriptor::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();
    }
    cObject *pp = (cObject *)object; (void)pp;
    switch (field) {
        case FIELD_className: return oppstring2string(pp->getClassName());
        case FIELD_fullName: return oppstring2string(pp->getFullName());
        case FIELD_fullPath: return oppstring2string(pp->getFullPath());
        case FIELD_info: return oppstring2string(pp->str());
        default: return "";
    }
}

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

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

class cNamedObjectDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_name,
    };
  public:
    cNamedObjectDescriptor();
    virtual ~cNamedObjectDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cNamedObjectDescriptor)

cNamedObjectDescriptor::cNamedObjectDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cNamedObject)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cNamedObjectDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cNamedObjectDescriptor::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 FIELD_name:
            if (!strcmp(propertyname, "group")) return "base";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "An editable string attribute of the object, also used for fullName and fullPath";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cNamedObjectDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cNamedObject *pp = (cNamedObject *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cNamedObjectDescriptor::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();
    }
    cNamedObject *pp = (cNamedObject *)object; (void)pp;
    switch (field) {
        case FIELD_name: return oppstring2string(pp->getName());
        default: return "";
    }
}

bool cNamedObjectDescriptor::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();
    }
    cNamedObject *pp = (cNamedObject *)object; (void)pp;
    switch (field) {
        case FIELD_name: pp->setName((value)); return true;
        default: return false;
    }
}

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

class cOwnedObjectDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_owner,
    };
  public:
    cOwnedObjectDescriptor();
    virtual ~cOwnedObjectDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cOwnedObjectDescriptor)

cOwnedObjectDescriptor::cOwnedObjectDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cOwnedObject)), "omnetpp::cNamedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cOwnedObjectDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cOwnedObjectDescriptor::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_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_owner
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

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

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

const char *cOwnedObjectDescriptor::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[] = {
        "omnetpp::cObject",    // FIELD_owner
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cOwnedObjectDescriptor::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 FIELD_owner:
            if (!strcmp(propertyname, "group")) return "base";
            if (!strcmp(propertyname, "hint")) return "Module or container this object belongs to";
            if (!strcmp(propertyname, "eventlog")) return "skip";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cOwnedObjectDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cOwnedObject *pp = (cOwnedObject *)object; (void)pp;
    switch (field) {
        case FIELD_owner: { const cObject * value = pp->getOwner(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cOwnedObjectDescriptor::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();
    }
    cOwnedObject *pp = (cOwnedObject *)object; (void)pp;
    switch (field) {
        case FIELD_owner: {std::stringstream out; out << pp->getOwner(); return out.str();}
        default: return "";
    }
}

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

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

void *cOwnedObjectDescriptor::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();
    }
    cOwnedObject *pp = (cOwnedObject *)object; (void)pp;
    switch (field) {
        case FIELD_owner: return toVoidPtr(pp->getOwner()); break;
        default: return nullptr;
    }
}

class cNoncopyableOwnedObjectDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cNoncopyableOwnedObjectDescriptor();
    virtual ~cNoncopyableOwnedObjectDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cNoncopyableOwnedObjectDescriptor)

cNoncopyableOwnedObjectDescriptor::cNoncopyableOwnedObjectDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cNoncopyableOwnedObject)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cNoncopyableOwnedObjectDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cNoncopyableOwnedObjectDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cNoncopyableOwnedObject *pp = (cNoncopyableOwnedObject *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cDefaultListDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_defaultList,
    };
  public:
    cDefaultListDescriptor();
    virtual ~cDefaultListDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cDefaultListDescriptor)

cDefaultListDescriptor::cDefaultListDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cDefaultList)), "omnetpp::cNoncopyableOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cDefaultListDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cDefaultListDescriptor::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_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_defaultList
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

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

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

const char *cDefaultListDescriptor::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[] = {
        "omnetpp::cOwnedObject",    // FIELD_defaultList
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **cDefaultListDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_defaultList: {
            static const char *names[] = { "getter", "sizeGetter", "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cDefaultListDescriptor::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 FIELD_defaultList:
            if (!strcmp(propertyname, "getter")) return "defaultListGet";
            if (!strcmp(propertyname, "sizeGetter")) return "defaultListSize";
            if (!strcmp(propertyname, "group")) return "owned objects";
            if (!strcmp(propertyname, "hint")) return "List of objects directly held by this component";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cDefaultListDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cDefaultList *pp = (cDefaultList *)object; (void)pp;
    switch (field) {
        case FIELD_defaultList: { const cOwnedObject * value = pp->defaultListGet(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cDefaultListDescriptor::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();
    }
    cDefaultList *pp = (cDefaultList *)object; (void)pp;
    switch (field) {
        case FIELD_defaultList: {std::stringstream out; out << pp->defaultListGet(i); return out.str();}
        default: return "";
    }
}

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

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

void *cDefaultListDescriptor::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();
    }
    cDefaultList *pp = (cDefaultList *)object; (void)pp;
    switch (field) {
        case FIELD_defaultList: return toVoidPtr(pp->defaultListGet(i)); break;
        default: return nullptr;
    }
}

class cDisplayStringDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_value,
    };
  public:
    cDisplayStringDescriptor();
    virtual ~cDisplayStringDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cDisplayStringDescriptor)

cDisplayStringDescriptor::cDisplayStringDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cDisplayString)), "")
{
    propertynames = nullptr;
}

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

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

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

const char *cDisplayStringDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

const char **cDisplayStringDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_value: {
            static const char *names[] = { "getter", "setter", "editable", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cDisplayStringDescriptor::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 FIELD_value:
            if (!strcmp(propertyname, "getter")) return "str";
            if (!strcmp(propertyname, "setter")) return "parse";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "The editable display string itself";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cDisplayStringDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cDisplayString *pp = (cDisplayString *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cDisplayStringDescriptor::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();
    }
    cDisplayString *pp = (cDisplayString *)object; (void)pp;
    switch (field) {
        case FIELD_value: return oppstring2string(pp->str());
        default: return "";
    }
}

bool cDisplayStringDescriptor::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();
    }
    cDisplayString *pp = (cDisplayString *)object; (void)pp;
    switch (field) {
        case FIELD_value: pp->parse((value)); return true;
        default: return false;
    }
}

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

class cPropertyDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_isImplicit,
        FIELD_index,
        FIELD_value,
    };
  public:
    cPropertyDescriptor();
    virtual ~cPropertyDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPropertyDescriptor)

cPropertyDescriptor::cPropertyDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cProperty)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cPropertyDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cPropertyDescriptor::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[] = {
        0,    // FIELD_isImplicit
        0,    // FIELD_index
        0,    // FIELD_value
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cPropertyDescriptor::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[] = {
        "isImplicit",
        "index",
        "value",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cPropertyDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isImplicit") == 0) return base+0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "index") == 0) return base+1;
    if (fieldName[0] == 'v' && strcmp(fieldName, "value") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cPropertyDescriptor::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[] = {
        "bool",    // FIELD_isImplicit
        "string",    // FIELD_index
        "string",    // FIELD_value
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cPropertyDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_isImplicit: {
            static const char *names[] = { "getter", "group",  nullptr };
            return names;
        }
        case FIELD_index: {
            static const char *names[] = { "group",  nullptr };
            return names;
        }
        case FIELD_value: {
            static const char *names[] = { "getter", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cPropertyDescriptor::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 FIELD_isImplicit:
            if (!strcmp(propertyname, "getter")) return "isImplicit";
            if (!strcmp(propertyname, "group")) return "fields";
            return nullptr;
        case FIELD_index:
            if (!strcmp(propertyname, "group")) return "fields";
            return nullptr;
        case FIELD_value:
            if (!strcmp(propertyname, "getter")) return "str";
            if (!strcmp(propertyname, "hint")) return "Name and value";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cPropertyDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cProperty *pp = (cProperty *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPropertyDescriptor::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();
    }
    cProperty *pp = (cProperty *)object; (void)pp;
    switch (field) {
        case FIELD_isImplicit: return bool2string(pp->isImplicit());
        case FIELD_index: return oppstring2string(pp->getIndex());
        case FIELD_value: return oppstring2string(pp->str());
        default: return "";
    }
}

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

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

class cComponent__SignalListenerListDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_signalName,
        FIELD_listeners,
    };
  public:
    cComponent__SignalListenerListDescriptor();
    virtual ~cComponent__SignalListenerListDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cComponent__SignalListenerListDescriptor)

cComponent__SignalListenerListDescriptor::cComponent__SignalListenerListDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cComponent::SignalListenerList)), "")
{
    propertynames = nullptr;
}

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

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

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

const char *cComponent__SignalListenerListDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cComponent__SignalListenerListDescriptor::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[] = {
        0,    // FIELD_signalName
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER,    // FIELD_listeners
    };
    return (field >= 0 && field < 2) ? fieldTypeFlags[field] : 0;
}

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

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

const char *cComponent__SignalListenerListDescriptor::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",    // FIELD_signalName
        "omnetpp::cIListener",    // FIELD_listeners
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **cComponent__SignalListenerListDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_signalName: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_listeners: {
            static const char *names[] = { "getter", "sizeGetter",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cComponent__SignalListenerListDescriptor::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 FIELD_signalName:
            if (!strcmp(propertyname, "hint")) return "Name of signal listened on";
            return nullptr;
        case FIELD_listeners:
            if (!strcmp(propertyname, "getter")) return "getListener";
            if (!strcmp(propertyname, "sizeGetter")) return "countListeners";
            return nullptr;
        default: return nullptr;
    }
}

int cComponent__SignalListenerListDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cComponent::SignalListenerList *pp = (cComponent::SignalListenerList *)object; (void)pp;
    switch (field) {
        case FIELD_listeners: return pp->countListeners();
        default: return 0;
    }
}

const char *cComponent__SignalListenerListDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cComponent::SignalListenerList *pp = (cComponent::SignalListenerList *)object; (void)pp;
    switch (field) {
        case FIELD_listeners: { const cIListener * value = pp->getListener(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cComponent__SignalListenerListDescriptor::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();
    }
    cComponent::SignalListenerList *pp = (cComponent::SignalListenerList *)object; (void)pp;
    switch (field) {
        case FIELD_signalName: return oppstring2string(pp->getSignalName());
        case FIELD_listeners: {std::stringstream out; out << pp->getListener(i); return out.str();}
        default: return "";
    }
}

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

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

void *cComponent__SignalListenerListDescriptor::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();
    }
    cComponent::SignalListenerList *pp = (cComponent::SignalListenerList *)object; (void)pp;
    switch (field) {
        case FIELD_listeners: return toVoidPtr(pp->getListener(i)); break;
        default: return nullptr;
    }
}

class cComponentDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_isModule,
        FIELD_componentType,
        FIELD_par,
        FIELD_properties_,
        FIELD_listenedSignals,
        FIELD_results,
    };
  public:
    cComponentDescriptor();
    virtual ~cComponentDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cComponentDescriptor)

cComponentDescriptor::cComponentDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cComponent)), "omnetpp::cDefaultList")
{
    propertynames = nullptr;
}

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

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

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

const char *cComponentDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cComponentDescriptor::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[] = {
        0,    // FIELD_isModule
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_componentType
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISCOBJECT,    // FIELD_par
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_properties_
        FD_ISARRAY | FD_ISCOMPOUND,    // FIELD_listenedSignals
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER,    // FIELD_results
    };
    return (field >= 0 && field < 6) ? fieldTypeFlags[field] : 0;
}

const char *cComponentDescriptor::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[] = {
        "isModule",
        "componentType",
        "par",
        "properties_",
        "listenedSignals",
        "results",
    };
    return (field >= 0 && field < 6) ? fieldNames[field] : nullptr;
}

int cComponentDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isModule") == 0) return base+0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "componentType") == 0) return base+1;
    if (fieldName[0] == 'p' && strcmp(fieldName, "par") == 0) return base+2;
    if (fieldName[0] == 'p' && strcmp(fieldName, "properties_") == 0) return base+3;
    if (fieldName[0] == 'l' && strcmp(fieldName, "listenedSignals") == 0) return base+4;
    if (fieldName[0] == 'r' && strcmp(fieldName, "results") == 0) return base+5;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cComponentDescriptor::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[] = {
        "bool",    // FIELD_isModule
        "omnetpp::cComponentType",    // FIELD_componentType
        "omnetpp::cPar",    // FIELD_par
        "omnetpp::cProperty",    // FIELD_properties_
        "omnetpp::cComponent::SignalListenerList",    // FIELD_listenedSignals
        "omnetpp::cResultRecorder",    // FIELD_results
    };
    return (field >= 0 && field < 6) ? fieldTypeStrings[field] : nullptr;
}

const char **cComponentDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_isModule: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_componentType: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_par: {
            static const char *names[] = { "getter", "sizeGetter", "label", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_properties_: {
            static const char *names[] = { "label", "getter", "sizeGetter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_listenedSignals: {
            static const char *names[] = { "getter", "sizeGetter", "toString", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_results: {
            static const char *names[] = { "getter", "sizeGetter", "toString", "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cComponentDescriptor::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 FIELD_isModule:
            if (!strcmp(propertyname, "getter")) return "isModule";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Whether this component is a module or a channel";
            return nullptr;
        case FIELD_componentType:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "The object that represents the type declaration for this component";
            return nullptr;
        case FIELD_par:
            if (!strcmp(propertyname, "getter")) return "par";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumParams";
            if (!strcmp(propertyname, "label")) return "parameters";
            if (!strcmp(propertyname, "group")) return "parameters,gates";
            if (!strcmp(propertyname, "hint")) return "NED parameters";
            return nullptr;
        case FIELD_properties_:
            if (!strcmp(propertyname, "label")) return "properties";
            if (!strcmp(propertyname, "getter")) return "->getProperties()->get(i)";
            if (!strcmp(propertyname, "sizeGetter")) return "->getProperties()->getNumProperties()";
            if (!strcmp(propertyname, "group")) return "parameters,gates";
            if (!strcmp(propertyname, "hint")) return "NED properties";
            return nullptr;
        case FIELD_listenedSignals:
            if (!strcmp(propertyname, "getter")) return "getListenerList";
            if (!strcmp(propertyname, "sizeGetter")) return "getSignalTableSize";
            if (!strcmp(propertyname, "toString")) return ".str()";
            if (!strcmp(propertyname, "group")) return "signals,statistics";
            if (!strcmp(propertyname, "hint")) return "Signal listener lists";
            return nullptr;
        case FIELD_results:
            if (!strcmp(propertyname, "getter")) return "->getResultRecorders()[i]";
            if (!strcmp(propertyname, "sizeGetter")) return "->getResultRecorders().size()";
            if (!strcmp(propertyname, "toString")) return "->str()";
            if (!strcmp(propertyname, "group")) return "signals,statistics";
            if (!strcmp(propertyname, "hint")) return "Statistical results collected in this component";
            return nullptr;
        default: return nullptr;
    }
}

int cComponentDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cComponent *pp = (cComponent *)object; (void)pp;
    switch (field) {
        case FIELD_par: return pp->getNumParams();
        case FIELD_properties_: return pp->getProperties()->getNumProperties();
        case FIELD_listenedSignals: return pp->getSignalTableSize();
        case FIELD_results: return pp->getResultRecorders().size();
        default: return 0;
    }
}

const char *cComponentDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cComponent *pp = (cComponent *)object; (void)pp;
    switch (field) {
        case FIELD_componentType: { const cComponentType * value = pp->getComponentType(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_properties_: { const cProperty * value = pp->getProperties()->get(i); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_results: { const cResultRecorder * value = pp->getResultRecorders()[i]; return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cComponentDescriptor::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();
    }
    cComponent *pp = (cComponent *)object; (void)pp;
    switch (field) {
        case FIELD_isModule: return bool2string(pp->isModule());
        case FIELD_componentType: {std::stringstream out; out << pp->getComponentType(); return out.str();}
        case FIELD_par: {std::stringstream out; out << pp->par(i); return out.str();}
        case FIELD_properties_: {std::stringstream out; out << pp->getProperties()->get(i); return out.str();}
        case FIELD_listenedSignals: return pp->getListenerList(i).str();
        case FIELD_results: return pp->getResultRecorders()[i]->str();
        default: return "";
    }
}

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

const char *cComponentDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_componentType: return omnetpp::opp_typename(typeid(cComponentType));
        case FIELD_par: return omnetpp::opp_typename(typeid(cPar));
        case FIELD_properties_: return omnetpp::opp_typename(typeid(cProperty));
        case FIELD_listenedSignals: return omnetpp::opp_typename(typeid(cComponent::SignalListenerList));
        case FIELD_results: return omnetpp::opp_typename(typeid(cResultRecorder));
        default: return nullptr;
    };
}

void *cComponentDescriptor::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();
    }
    cComponent *pp = (cComponent *)object; (void)pp;
    switch (field) {
        case FIELD_componentType: return toVoidPtr(pp->getComponentType()); break;
        case FIELD_par: return toVoidPtr(&pp->par(i)); break;
        case FIELD_properties_: return toVoidPtr(pp->getProperties()->get(i)); break;
        case FIELD_listenedSignals: return toVoidPtr(&pp->getListenerList(i)); break;
        case FIELD_results: return toVoidPtr(pp->getResultRecorders()[i]); break;
        default: return nullptr;
    }
}

class cChannelDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_displayString,
    };
  public:
    cChannelDescriptor();
    virtual ~cChannelDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cChannelDescriptor)

cChannelDescriptor::cChannelDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cChannel)), "omnetpp::cComponent")
{
    propertynames = nullptr;
}

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

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

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

const char *cChannelDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "channel";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

int cChannelDescriptor::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;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cChannelDescriptor::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[] = {
        "omnetpp::cDisplayString",    // FIELD_displayString
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **cChannelDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_displayString: {
            static const char *names[] = { "group", "hint", "editable", "setter", "fromString", "toString", "getter",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cChannelDescriptor::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 FIELD_displayString:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Controls appearance of this channel in the GUI";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "setter")) return "setDisplayString";
            if (!strcmp(propertyname, "fromString")) return "$";
            if (!strcmp(propertyname, "toString")) return ".str()";
            if (!strcmp(propertyname, "getter")) return "getDisplayString";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cChannelDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cChannel *pp = (cChannel *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cChannelDescriptor::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();
    }
    cChannel *pp = (cChannel *)object; (void)pp;
    switch (field) {
        case FIELD_displayString: return pp->getDisplayString().str();
        default: return "";
    }
}

bool cChannelDescriptor::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();
    }
    cChannel *pp = (cChannel *)object; (void)pp;
    switch (field) {
        case FIELD_displayString: pp->setDisplayString(value); return true;
        default: return false;
    }
}

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

void *cChannelDescriptor::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();
    }
    cChannel *pp = (cChannel *)object; (void)pp;
    switch (field) {
        case FIELD_displayString: return toVoidPtr(&pp->getDisplayString()); break;
        default: return nullptr;
    }
}

class cIdealChannelDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cIdealChannelDescriptor();
    virtual ~cIdealChannelDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cIdealChannelDescriptor)

cIdealChannelDescriptor::cIdealChannelDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cIdealChannel)), "omnetpp::cChannel")
{
    propertynames = nullptr;
}

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

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

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

const char *cIdealChannelDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cIdealChannelDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cIdealChannel *pp = (cIdealChannel *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cDelayChannelDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cDelayChannelDescriptor();
    virtual ~cDelayChannelDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cDelayChannelDescriptor)

cDelayChannelDescriptor::cDelayChannelDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cDelayChannel)), "omnetpp::cChannel")
{
    propertynames = nullptr;
}

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

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

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

const char *cDelayChannelDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cDelayChannelDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cDelayChannel *pp = (cDelayChannel *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cDatarateChannelDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_isBusy,
        FIELD_transmissionFinishTime,
    };
  public:
    cDatarateChannelDescriptor();
    virtual ~cDatarateChannelDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cDatarateChannelDescriptor)

cDatarateChannelDescriptor::cDatarateChannelDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cDatarateChannel)), "omnetpp::cChannel")
{
    propertynames = nullptr;
}

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

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

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

const char *cDatarateChannelDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

const char *cDatarateChannelDescriptor::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[] = {
        "bool",    // FIELD_isBusy
        "omnetpp::simtime_t",    // FIELD_transmissionFinishTime
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **cDatarateChannelDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_isBusy: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_transmissionFinishTime: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cDatarateChannelDescriptor::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 FIELD_isBusy:
            if (!strcmp(propertyname, "getter")) return "isBusy";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "If channel is currently transmitting";
            return nullptr;
        case FIELD_transmissionFinishTime:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "If busy: when currently active transmissions will finish";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cDatarateChannelDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cDatarateChannel *pp = (cDatarateChannel *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cDatarateChannelDescriptor::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();
    }
    cDatarateChannel *pp = (cDatarateChannel *)object; (void)pp;
    switch (field) {
        case FIELD_isBusy: return bool2string(pp->isBusy());
        case FIELD_transmissionFinishTime: return simtime2string(pp->getTransmissionFinishTime());
        default: return "";
    }
}

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

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

class cModuleDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_id,
        FIELD_isSimple,
        FIELD_isVector,
        FIELD_index,
        FIELD_size,
        FIELD_builtinAnimationsAllowed,
        FIELD_displayString,
        FIELD_gate,
        FIELD_canvas,
        FIELD_osgCanvas,
    };
  public:
    cModuleDescriptor();
    virtual ~cModuleDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cModuleDescriptor)

cModuleDescriptor::cModuleDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cModule)), "omnetpp::cComponent")
{
    propertynames = nullptr;
}

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

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

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

const char *cModuleDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "compound";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cModuleDescriptor::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[] = {
        0,    // FIELD_id
        0,    // FIELD_isSimple
        0,    // FIELD_isVector
        0,    // FIELD_index
        0,    // FIELD_size
        FD_ISEDITABLE,    // FIELD_builtinAnimationsAllowed
        FD_ISCOMPOUND | FD_ISEDITABLE,    // FIELD_displayString
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_gate
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_canvas
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_osgCanvas
    };
    return (field >= 0 && field < 10) ? fieldTypeFlags[field] : 0;
}

const char *cModuleDescriptor::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[] = {
        "id",
        "isSimple",
        "isVector",
        "index",
        "size",
        "builtinAnimationsAllowed",
        "displayString",
        "gate",
        "canvas",
        "osgCanvas",
    };
    return (field >= 0 && field < 10) ? fieldNames[field] : nullptr;
}

int cModuleDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "id") == 0) return base+0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isSimple") == 0) return base+1;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isVector") == 0) return base+2;
    if (fieldName[0] == 'i' && strcmp(fieldName, "index") == 0) return base+3;
    if (fieldName[0] == 's' && strcmp(fieldName, "size") == 0) return base+4;
    if (fieldName[0] == 'b' && strcmp(fieldName, "builtinAnimationsAllowed") == 0) return base+5;
    if (fieldName[0] == 'd' && strcmp(fieldName, "displayString") == 0) return base+6;
    if (fieldName[0] == 'g' && strcmp(fieldName, "gate") == 0) return base+7;
    if (fieldName[0] == 'c' && strcmp(fieldName, "canvas") == 0) return base+8;
    if (fieldName[0] == 'o' && strcmp(fieldName, "osgCanvas") == 0) return base+9;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cModuleDescriptor::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[] = {
        "int",    // FIELD_id
        "bool",    // FIELD_isSimple
        "bool",    // FIELD_isVector
        "int",    // FIELD_index
        "int",    // FIELD_size
        "bool",    // FIELD_builtinAnimationsAllowed
        "omnetpp::cDisplayString",    // FIELD_displayString
        "omnetpp::cGate",    // FIELD_gate
        "omnetpp::cCanvas",    // FIELD_canvas
        "omnetpp::cOsgCanvas",    // FIELD_osgCanvas
    };
    return (field >= 0 && field < 10) ? fieldTypeStrings[field] : nullptr;
}

const char **cModuleDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_id: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isSimple: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isVector: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_index: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_size: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_builtinAnimationsAllowed: {
            static const char *names[] = { "editable", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_displayString: {
            static const char *names[] = { "group", "hint", "editable", "setter", "fromString", "toString", "getter",  nullptr };
            return names;
        }
        case FIELD_gate: {
            static const char *names[] = { "sizeGetter", "getter", "group", "label", "hint",  nullptr };
            return names;
        }
        case FIELD_canvas: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_osgCanvas: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cModuleDescriptor::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 FIELD_id:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Unique module ID -- IDs of deleted modules are not issued again";
            return nullptr;
        case FIELD_isSimple:
            if (!strcmp(propertyname, "getter")) return "isSimple";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Whether this is a simple module";
            return nullptr;
        case FIELD_isVector:
            if (!strcmp(propertyname, "getter")) return "isVector";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Whether this module is part of a module vector";
            return nullptr;
        case FIELD_index:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "If vector: index of this module in its module vector";
            return nullptr;
        case FIELD_size:
            if (!strcmp(propertyname, "getter")) return "size";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "If vector: size of module vector this module belongs to";
            return nullptr;
        case FIELD_builtinAnimationsAllowed:
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Whether built-in animations are enabled on this module's graphical inspector";
            return nullptr;
        case FIELD_displayString:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Controls appearance of this module in the GUI";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "setter")) return "setDisplayString";
            if (!strcmp(propertyname, "fromString")) return "$";
            if (!strcmp(propertyname, "toString")) return ".str()";
            if (!strcmp(propertyname, "getter")) return "getDisplayString";
            return nullptr;
        case FIELD_gate:
            if (!strcmp(propertyname, "sizeGetter")) return "gateCount";
            if (!strcmp(propertyname, "getter")) return "gateByOrdinal";
            if (!strcmp(propertyname, "group")) return "parameters,gates";
            if (!strcmp(propertyname, "label")) return "gates";
            if (!strcmp(propertyname, "hint")) return "Module gates";
            return nullptr;
        case FIELD_canvas:
            if (!strcmp(propertyname, "getter")) return "getCanvasIfExists";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Built-in canvas instance";
            return nullptr;
        case FIELD_osgCanvas:
            if (!strcmp(propertyname, "getter")) return "getOsgCanvasIfExists";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Built-in 3D (OpenSceneGraph) canvas instance";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cModuleDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cModule *pp = (cModule *)object; (void)pp;
    switch (field) {
        case FIELD_gate: { const cGate * value = pp->gateByOrdinal(i); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_canvas: { const cCanvas * value = pp->getCanvasIfExists(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_osgCanvas: { const cOsgCanvas * value = pp->getOsgCanvasIfExists(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cModuleDescriptor::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();
    }
    cModule *pp = (cModule *)object; (void)pp;
    switch (field) {
        case FIELD_id: return long2string(pp->getId());
        case FIELD_isSimple: return bool2string(pp->isSimple());
        case FIELD_isVector: return bool2string(pp->isVector());
        case FIELD_index: return long2string(pp->getIndex());
        case FIELD_size: return long2string(pp->size());
        case FIELD_builtinAnimationsAllowed: return bool2string(pp->getBuiltinAnimationsAllowed());
        case FIELD_displayString: return pp->getDisplayString().str();
        case FIELD_gate: {std::stringstream out; out << pp->gateByOrdinal(i); return out.str();}
        case FIELD_canvas: {std::stringstream out; out << pp->getCanvasIfExists(); return out.str();}
        case FIELD_osgCanvas: {std::stringstream out; out << pp->getOsgCanvasIfExists(); return out.str();}
        default: return "";
    }
}

bool cModuleDescriptor::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();
    }
    cModule *pp = (cModule *)object; (void)pp;
    switch (field) {
        case FIELD_builtinAnimationsAllowed: pp->setBuiltinAnimationsAllowed(string2bool(value)); return true;
        case FIELD_displayString: pp->setDisplayString(value); return true;
        default: return false;
    }
}

const char *cModuleDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_displayString: return omnetpp::opp_typename(typeid(cDisplayString));
        case FIELD_gate: return omnetpp::opp_typename(typeid(cGate));
        case FIELD_canvas: return omnetpp::opp_typename(typeid(cCanvas));
        case FIELD_osgCanvas: return omnetpp::opp_typename(typeid(cOsgCanvas));
        default: return nullptr;
    };
}

void *cModuleDescriptor::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();
    }
    cModule *pp = (cModule *)object; (void)pp;
    switch (field) {
        case FIELD_displayString: return toVoidPtr(&pp->getDisplayString()); break;
        case FIELD_gate: return toVoidPtr(pp->gateByOrdinal(i)); break;
        case FIELD_canvas: return toVoidPtr(pp->getCanvasIfExists()); break;
        case FIELD_osgCanvas: return toVoidPtr(pp->getOsgCanvasIfExists()); break;
        default: return nullptr;
    }
}

class cSimpleModuleDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_isTerminated,
        FIELD_usesActivity,
        FIELD_stackSize,
        FIELD_stackUsage,
    };
  public:
    cSimpleModuleDescriptor();
    virtual ~cSimpleModuleDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cSimpleModuleDescriptor)

cSimpleModuleDescriptor::cSimpleModuleDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cSimpleModule)), "omnetpp::cModule")
{
    propertynames = nullptr;
}

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

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

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

const char *cSimpleModuleDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "simple";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cSimpleModuleDescriptor::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[] = {
        0,    // FIELD_isTerminated
        0,    // FIELD_usesActivity
        0,    // FIELD_stackSize
        0,    // FIELD_stackUsage
    };
    return (field >= 0 && field < 4) ? fieldTypeFlags[field] : 0;
}

const char *cSimpleModuleDescriptor::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[] = {
        "isTerminated",
        "usesActivity",
        "stackSize",
        "stackUsage",
    };
    return (field >= 0 && field < 4) ? fieldNames[field] : nullptr;
}

int cSimpleModuleDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isTerminated") == 0) return base+0;
    if (fieldName[0] == 'u' && strcmp(fieldName, "usesActivity") == 0) return base+1;
    if (fieldName[0] == 's' && strcmp(fieldName, "stackSize") == 0) return base+2;
    if (fieldName[0] == 's' && strcmp(fieldName, "stackUsage") == 0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cSimpleModuleDescriptor::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[] = {
        "bool",    // FIELD_isTerminated
        "bool",    // FIELD_usesActivity
        "unsigned int",    // FIELD_stackSize
        "unsigned int",    // FIELD_stackUsage
    };
    return (field >= 0 && field < 4) ? fieldTypeStrings[field] : nullptr;
}

const char **cSimpleModuleDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_isTerminated: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_usesActivity: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_stackSize: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_stackUsage: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cSimpleModuleDescriptor::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 FIELD_isTerminated:
            if (!strcmp(propertyname, "getter")) return "isTerminated";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Whether this module has terminated";
            return nullptr;
        case FIELD_usesActivity:
            if (!strcmp(propertyname, "getter")) return "usesActivity";
            if (!strcmp(propertyname, "group")) return "activity";
            if (!strcmp(propertyname, "hint")) return "Whether this simple module was programmed using the \"activity\" or the \"handleMessage\" C++ method";
            return nullptr;
        case FIELD_stackSize:
            if (!strcmp(propertyname, "group")) return "activity";
            if (!strcmp(propertyname, "hint")) return "If module uses \"activity\": stack size allocated for this module -- zero means info not available";
            return nullptr;
        case FIELD_stackUsage:
            if (!strcmp(propertyname, "group")) return "activity";
            if (!strcmp(propertyname, "hint")) return "If module uses \"activity\": stack actually used by this module -- zero means info not available";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cSimpleModuleDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cSimpleModule *pp = (cSimpleModule *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cSimpleModuleDescriptor::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();
    }
    cSimpleModule *pp = (cSimpleModule *)object; (void)pp;
    switch (field) {
        case FIELD_isTerminated: return bool2string(pp->isTerminated());
        case FIELD_usesActivity: return bool2string(pp->usesActivity());
        case FIELD_stackSize: return ulong2string(pp->getStackSize());
        case FIELD_stackUsage: return ulong2string(pp->getStackUsage());
        default: return "";
    }
}

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

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

class cComponentTypeDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_nedSource,
    };
  public:
    cComponentTypeDescriptor();
    virtual ~cComponentTypeDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cComponentTypeDescriptor)

cComponentTypeDescriptor::cComponentTypeDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cComponentType)), "omnetpp::cNoncopyableOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cComponentTypeDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cComponentTypeDescriptor::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 FIELD_nedSource:
            if (!strcmp(propertyname, "getter")) return "getNedSource";
            if (!strcmp(propertyname, "hint")) return "NED source of component if available";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cComponentTypeDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cComponentType *pp = (cComponentType *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cComponentTypeDescriptor::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();
    }
    cComponentType *pp = (cComponentType *)object; (void)pp;
    switch (field) {
        case FIELD_nedSource: return oppstring2string(pp->getNedSource());
        default: return "";
    }
}

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

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

class cModuleTypeDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_isNetwork,
    };
  public:
    cModuleTypeDescriptor();
    virtual ~cModuleTypeDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cModuleTypeDescriptor)

cModuleTypeDescriptor::cModuleTypeDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cModuleType)), "omnetpp::cComponentType")
{
    propertynames = nullptr;
}

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

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

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

const char *cModuleTypeDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cModuleTypeDescriptor::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 FIELD_isNetwork:
            if (!strcmp(propertyname, "getter")) return "isNetwork";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Whether this module type can be used as toplevel module";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cModuleTypeDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cModuleType *pp = (cModuleType *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cModuleTypeDescriptor::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();
    }
    cModuleType *pp = (cModuleType *)object; (void)pp;
    switch (field) {
        case FIELD_isNetwork: return bool2string(pp->isNetwork());
        default: return "";
    }
}

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

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

class cChannelTypeDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cChannelTypeDescriptor();
    virtual ~cChannelTypeDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cChannelTypeDescriptor)

cChannelTypeDescriptor::cChannelTypeDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cChannelType)), "omnetpp::cComponentType")
{
    propertynames = nullptr;
}

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

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

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

const char *cChannelTypeDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cChannelTypeDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cChannelType *pp = (cChannelType *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cRegistrationListDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_contents,
    };
  public:
    cRegistrationListDescriptor();
    virtual ~cRegistrationListDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cRegistrationListDescriptor)

cRegistrationListDescriptor::cRegistrationListDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cRegistrationList)), "omnetpp::cNamedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cRegistrationListDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cRegistrationListDescriptor::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_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_contents
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

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

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

const char *cRegistrationListDescriptor::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[] = {
        "omnetpp::cObject",    // FIELD_contents
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cRegistrationListDescriptor::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 FIELD_contents:
            if (!strcmp(propertyname, "getter")) return "get";
            if (!strcmp(propertyname, "sizeGetter")) return "size";
            if (!strcmp(propertyname, "hint")) return "Contained objects";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cRegistrationListDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cRegistrationList *pp = (cRegistrationList *)object; (void)pp;
    switch (field) {
        case FIELD_contents: { const cObject * value = pp->get(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cRegistrationListDescriptor::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();
    }
    cRegistrationList *pp = (cRegistrationList *)object; (void)pp;
    switch (field) {
        case FIELD_contents: {std::stringstream out; out << pp->get(i); return out.str();}
        default: return "";
    }
}

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

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

void *cRegistrationListDescriptor::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();
    }
    cRegistrationList *pp = (cRegistrationList *)object; (void)pp;
    switch (field) {
        case FIELD_contents: return toVoidPtr(pp->get(i)); break;
        default: return nullptr;
    }
}

class cGateDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_type,
        FIELD_id,
        FIELD_isVector,
        FIELD_index,
        FIELD_deliverOnReceptionStart,
        FIELD_channel,
        FIELD_previousGate,
        FIELD_nextGate,
        FIELD_pathStartGate,
        FIELD_pathEndGate,
        FIELD_isConnectedOutside,
        FIELD_isConnectedInside,
        FIELD_isConnected,
        FIELD_isPathOK,
    };
  public:
    cGateDescriptor();
    virtual ~cGateDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cGateDescriptor)

cGateDescriptor::cGateDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cGate)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cGateDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "gate";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cGateDescriptor::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[] = {
        0,    // FIELD_type
        0,    // FIELD_id
        0,    // FIELD_isVector
        0,    // FIELD_index
        0,    // FIELD_deliverOnReceptionStart
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_channel
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_previousGate
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_nextGate
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_pathStartGate
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_pathEndGate
        0,    // FIELD_isConnectedOutside
        0,    // FIELD_isConnectedInside
        0,    // FIELD_isConnected
        0,    // FIELD_isPathOK
    };
    return (field >= 0 && field < 14) ? fieldTypeFlags[field] : 0;
}

const char *cGateDescriptor::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[] = {
        "type",
        "id",
        "isVector",
        "index",
        "deliverOnReceptionStart",
        "channel",
        "previousGate",
        "nextGate",
        "pathStartGate",
        "pathEndGate",
        "isConnectedOutside",
        "isConnectedInside",
        "isConnected",
        "isPathOK",
    };
    return (field >= 0 && field < 14) ? fieldNames[field] : nullptr;
}

int cGateDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 't' && strcmp(fieldName, "type") == 0) return base+0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "id") == 0) return base+1;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isVector") == 0) return base+2;
    if (fieldName[0] == 'i' && strcmp(fieldName, "index") == 0) return base+3;
    if (fieldName[0] == 'd' && strcmp(fieldName, "deliverOnReceptionStart") == 0) return base+4;
    if (fieldName[0] == 'c' && strcmp(fieldName, "channel") == 0) return base+5;
    if (fieldName[0] == 'p' && strcmp(fieldName, "previousGate") == 0) return base+6;
    if (fieldName[0] == 'n' && strcmp(fieldName, "nextGate") == 0) return base+7;
    if (fieldName[0] == 'p' && strcmp(fieldName, "pathStartGate") == 0) return base+8;
    if (fieldName[0] == 'p' && strcmp(fieldName, "pathEndGate") == 0) return base+9;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isConnectedOutside") == 0) return base+10;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isConnectedInside") == 0) return base+11;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isConnected") == 0) return base+12;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isPathOK") == 0) return base+13;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cGateDescriptor::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[] = {
        "char",    // FIELD_type
        "int",    // FIELD_id
        "bool",    // FIELD_isVector
        "int",    // FIELD_index
        "bool",    // FIELD_deliverOnReceptionStart
        "omnetpp::cChannel",    // FIELD_channel
        "omnetpp::cGate",    // FIELD_previousGate
        "omnetpp::cGate",    // FIELD_nextGate
        "omnetpp::cGate",    // FIELD_pathStartGate
        "omnetpp::cGate",    // FIELD_pathEndGate
        "bool",    // FIELD_isConnectedOutside
        "bool",    // FIELD_isConnectedInside
        "bool",    // FIELD_isConnected
        "bool",    // FIELD_isPathOK
    };
    return (field >= 0 && field < 14) ? fieldTypeStrings[field] : nullptr;
}

const char **cGateDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_type: {
            static const char *names[] = { "group", "enum", "hint", "enum",  nullptr };
            return names;
        }
        case FIELD_id: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isVector: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_index: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_deliverOnReceptionStart: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_channel: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_previousGate: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_nextGate: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_pathStartGate: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_pathEndGate: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isConnectedOutside: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isConnectedInside: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isConnected: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isPathOK: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cGateDescriptor::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 FIELD_type:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "enum")) return "cGate::Type";
            if (!strcmp(propertyname, "hint")) return "Gate type";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cGate::Type";
            return nullptr;
        case FIELD_id:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Gate id, unique within this module";
            return nullptr;
        case FIELD_isVector:
            if (!strcmp(propertyname, "getter")) return "isVector";
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Whether this gate is part of a gate vector";
            return nullptr;
        case FIELD_index:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "If vector: index of this gate within its gate vector";
            return nullptr;
        case FIELD_deliverOnReceptionStart:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Only for simple module input gates, and if message transmission duration is nonzero: whether messages arriving on this gate will be given to the module at the start or the end of the reception";
            return nullptr;
        case FIELD_channel:
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "Channel object associated with the connection";
            return nullptr;
        case FIELD_previousGate:
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "The gate this one is connected to -- for output gates this points out of this module, and for input gates it points inside";
            return nullptr;
        case FIELD_nextGate:
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "The gate whose \"previousGate\" is this gate -- note that \"previous\" and \"next\" correspond to the direction of messages";
            return nullptr;
        case FIELD_pathStartGate:
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "The last gate in the \"previousGate->previousGate->previousGate...\" chain";
            return nullptr;
        case FIELD_pathEndGate:
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "The last gate in the \"nextGate->nextGate->nextGate...\" chain";
            return nullptr;
        case FIELD_isConnectedOutside:
            if (!strcmp(propertyname, "getter")) return "isConnectedOutside";
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "For an output gate this checks nextGate, and previousGate for an input gate";
            return nullptr;
        case FIELD_isConnectedInside:
            if (!strcmp(propertyname, "getter")) return "isConnectedInside";
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "For an input gate this checks nextGate, and previousGate for an output gate";
            return nullptr;
        case FIELD_isConnected:
            if (!strcmp(propertyname, "getter")) return "isConnected";
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "Whether the gate is fully connected -- both inside and outside for a compound module gate, and outside for a simple module gate";
            return nullptr;
        case FIELD_isPathOK:
            if (!strcmp(propertyname, "getter")) return "isPathOK";
            if (!strcmp(propertyname, "group")) return "connection";
            if (!strcmp(propertyname, "hint")) return "The chain of connections is OK if it starts and ends at a simple module";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cGateDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cGate *pp = (cGate *)object; (void)pp;
    switch (field) {
        case FIELD_channel: { const cChannel * value = pp->getChannel(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_previousGate: { const cGate * value = pp->getPreviousGate(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_nextGate: { const cGate * value = pp->getNextGate(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_pathStartGate: { const cGate * value = pp->getPathStartGate(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_pathEndGate: { const cGate * value = pp->getPathEndGate(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cGateDescriptor::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();
    }
    cGate *pp = (cGate *)object; (void)pp;
    switch (field) {
        case FIELD_type: return enum2string(pp->getType(), "omnetpp::cGate::Type");
        case FIELD_id: return long2string(pp->getId());
        case FIELD_isVector: return bool2string(pp->isVector());
        case FIELD_index: return long2string(pp->getIndex());
        case FIELD_deliverOnReceptionStart: return bool2string(pp->getDeliverOnReceptionStart());
        case FIELD_channel: {std::stringstream out; out << pp->getChannel(); return out.str();}
        case FIELD_previousGate: {std::stringstream out; out << pp->getPreviousGate(); return out.str();}
        case FIELD_nextGate: {std::stringstream out; out << pp->getNextGate(); return out.str();}
        case FIELD_pathStartGate: {std::stringstream out; out << pp->getPathStartGate(); return out.str();}
        case FIELD_pathEndGate: {std::stringstream out; out << pp->getPathEndGate(); return out.str();}
        case FIELD_isConnectedOutside: return bool2string(pp->isConnectedOutside());
        case FIELD_isConnectedInside: return bool2string(pp->isConnectedInside());
        case FIELD_isConnected: return bool2string(pp->isConnected());
        case FIELD_isPathOK: return bool2string(pp->isPathOK());
        default: return "";
    }
}

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

const char *cGateDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_channel: return omnetpp::opp_typename(typeid(cChannel));
        case FIELD_previousGate: return omnetpp::opp_typename(typeid(cGate));
        case FIELD_nextGate: return omnetpp::opp_typename(typeid(cGate));
        case FIELD_pathStartGate: return omnetpp::opp_typename(typeid(cGate));
        case FIELD_pathEndGate: return omnetpp::opp_typename(typeid(cGate));
        default: return nullptr;
    };
}

void *cGateDescriptor::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();
    }
    cGate *pp = (cGate *)object; (void)pp;
    switch (field) {
        case FIELD_channel: return toVoidPtr(pp->getChannel()); break;
        case FIELD_previousGate: return toVoidPtr(pp->getPreviousGate()); break;
        case FIELD_nextGate: return toVoidPtr(pp->getNextGate()); break;
        case FIELD_pathStartGate: return toVoidPtr(pp->getPathStartGate()); break;
        case FIELD_pathEndGate: return toVoidPtr(pp->getPathEndGate()); break;
        default: return nullptr;
    }
}

class cArrayDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_takeOwnership,
        FIELD_contents,
    };
  public:
    cArrayDescriptor();
    virtual ~cArrayDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cArrayDescriptor)

cArrayDescriptor::cArrayDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cArray)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cArrayDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "container";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cArrayDescriptor::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,    // FIELD_takeOwnership
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_contents
    };
    return (field >= 0 && field < 2) ? fieldTypeFlags[field] : 0;
}

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

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

const char *cArrayDescriptor::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[] = {
        "bool",    // FIELD_takeOwnership
        "omnetpp::cObject",    // FIELD_contents
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **cArrayDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_takeOwnership: {
            static const char *names[] = { "group", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_contents: {
            static const char *names[] = { "getter", "sizeGetter", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cArrayDescriptor::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 FIELD_takeOwnership:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "Whether the array should own the objects inserted into it";
            return nullptr;
        case FIELD_contents:
            if (!strcmp(propertyname, "getter")) return "get";
            if (!strcmp(propertyname, "sizeGetter")) return "size";
            if (!strcmp(propertyname, "hint")) return "Objects contained in the array";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cArrayDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cArray *pp = (cArray *)object; (void)pp;
    switch (field) {
        case FIELD_contents: { const cObject * value = pp->get(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cArrayDescriptor::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();
    }
    cArray *pp = (cArray *)object; (void)pp;
    switch (field) {
        case FIELD_takeOwnership: return bool2string(pp->getTakeOwnership());
        case FIELD_contents: {std::stringstream out; out << pp->get(i); return out.str();}
        default: return "";
    }
}

bool cArrayDescriptor::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();
    }
    cArray *pp = (cArray *)object; (void)pp;
    switch (field) {
        case FIELD_takeOwnership: pp->setTakeOwnership(string2bool(value)); return true;
        default: return false;
    }
}

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

void *cArrayDescriptor::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();
    }
    cArray *pp = (cArray *)object; (void)pp;
    switch (field) {
        case FIELD_contents: return toVoidPtr(pp->get(i)); break;
        default: return nullptr;
    }
}

class cEventDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_schedulingPriority,
        FIELD_targetObject,
        FIELD_isScheduled,
        FIELD_arrivalTime,
    };
  public:
    cEventDescriptor();
    virtual ~cEventDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cEventDescriptor)

cEventDescriptor::cEventDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cEvent)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cEventDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cEventDescriptor::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,    // FIELD_schedulingPriority
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_targetObject
        0,    // FIELD_isScheduled
        0,    // FIELD_arrivalTime
    };
    return (field >= 0 && field < 4) ? fieldTypeFlags[field] : 0;
}

const char *cEventDescriptor::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[] = {
        "schedulingPriority",
        "targetObject",
        "isScheduled",
        "arrivalTime",
    };
    return (field >= 0 && field < 4) ? fieldNames[field] : nullptr;
}

int cEventDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 's' && strcmp(fieldName, "schedulingPriority") == 0) return base+0;
    if (fieldName[0] == 't' && strcmp(fieldName, "targetObject") == 0) return base+1;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isScheduled") == 0) return base+2;
    if (fieldName[0] == 'a' && strcmp(fieldName, "arrivalTime") == 0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cEventDescriptor::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[] = {
        "short",    // FIELD_schedulingPriority
        "omnetpp::cObject",    // FIELD_targetObject
        "bool",    // FIELD_isScheduled
        "omnetpp::simtime_t",    // FIELD_arrivalTime
    };
    return (field >= 0 && field < 4) ? fieldTypeStrings[field] : nullptr;
}

const char **cEventDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_schedulingPriority: {
            static const char *names[] = { "group", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_targetObject: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isScheduled: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_arrivalTime: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cEventDescriptor::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 FIELD_schedulingPriority:
            if (!strcmp(propertyname, "group")) return "event";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "Controls order of messages with equal timestamps in FES";
            return nullptr;
        case FIELD_targetObject:
            if (!strcmp(propertyname, "group")) return "event";
            if (!strcmp(propertyname, "hint")) return "The object this message will be delivered to";
            return nullptr;
        case FIELD_isScheduled:
            if (!strcmp(propertyname, "getter")) return "isScheduled";
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Whether event or message is currently scheduled (or in transit)";
            return nullptr;
        case FIELD_arrivalTime:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Simulation time the event or message will be (or was) delivered";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cEventDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cEvent *pp = (cEvent *)object; (void)pp;
    switch (field) {
        case FIELD_targetObject: { const cObject * value = pp->getTargetObject(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cEventDescriptor::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();
    }
    cEvent *pp = (cEvent *)object; (void)pp;
    switch (field) {
        case FIELD_schedulingPriority: return long2string(pp->getSchedulingPriority());
        case FIELD_targetObject: {std::stringstream out; out << pp->getTargetObject(); return out.str();}
        case FIELD_isScheduled: return bool2string(pp->isScheduled());
        case FIELD_arrivalTime: return simtime2string(pp->getArrivalTime());
        default: return "";
    }
}

bool cEventDescriptor::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();
    }
    cEvent *pp = (cEvent *)object; (void)pp;
    switch (field) {
        case FIELD_schedulingPriority: pp->setSchedulingPriority(string2long(value)); return true;
        default: return false;
    }
}

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

void *cEventDescriptor::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();
    }
    cEvent *pp = (cEvent *)object; (void)pp;
    switch (field) {
        case FIELD_targetObject: return toVoidPtr(pp->getTargetObject()); break;
        default: return nullptr;
    }
}

class cMessageDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_id,
        FIELD_treeId,
        FIELD_kind,
        FIELD_displayString,
        FIELD_controlInfo,
        FIELD_parList,
        FIELD_isSelfMessage,
        FIELD_creationTime,
        FIELD_sendingTime,
        FIELD_timestamp,
        FIELD_senderModuleId,
        FIELD_senderGateId,
        FIELD_senderModule,
        FIELD_senderGate,
        FIELD_arrivalModuleId,
        FIELD_arrivalGateId,
        FIELD_arrivalModule,
        FIELD_arrivalGate,
    };
  public:
    cMessageDescriptor();
    virtual ~cMessageDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cMessageDescriptor)

cMessageDescriptor::cMessageDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cMessage)), "omnetpp::cEvent")
{
    propertynames = nullptr;
}

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

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

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

const char *cMessageDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "message";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cMessageDescriptor::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[] = {
        0,    // FIELD_id
        0,    // FIELD_treeId
        FD_ISEDITABLE,    // FIELD_kind
        0,    // FIELD_displayString
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_controlInfo
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_parList
        0,    // FIELD_isSelfMessage
        0,    // FIELD_creationTime
        0,    // FIELD_sendingTime
        FD_ISEDITABLE,    // FIELD_timestamp
        0,    // FIELD_senderModuleId
        0,    // FIELD_senderGateId
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_senderModule
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_senderGate
        0,    // FIELD_arrivalModuleId
        0,    // FIELD_arrivalGateId
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_arrivalModule
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_arrivalGate
    };
    return (field >= 0 && field < 18) ? fieldTypeFlags[field] : 0;
}

const char *cMessageDescriptor::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[] = {
        "id",
        "treeId",
        "kind",
        "displayString",
        "controlInfo",
        "parList",
        "isSelfMessage",
        "creationTime",
        "sendingTime",
        "timestamp",
        "senderModuleId",
        "senderGateId",
        "senderModule",
        "senderGate",
        "arrivalModuleId",
        "arrivalGateId",
        "arrivalModule",
        "arrivalGate",
    };
    return (field >= 0 && field < 18) ? fieldNames[field] : nullptr;
}

int cMessageDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "id") == 0) return base+0;
    if (fieldName[0] == 't' && strcmp(fieldName, "treeId") == 0) return base+1;
    if (fieldName[0] == 'k' && strcmp(fieldName, "kind") == 0) return base+2;
    if (fieldName[0] == 'd' && strcmp(fieldName, "displayString") == 0) return base+3;
    if (fieldName[0] == 'c' && strcmp(fieldName, "controlInfo") == 0) return base+4;
    if (fieldName[0] == 'p' && strcmp(fieldName, "parList") == 0) return base+5;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isSelfMessage") == 0) return base+6;
    if (fieldName[0] == 'c' && strcmp(fieldName, "creationTime") == 0) return base+7;
    if (fieldName[0] == 's' && strcmp(fieldName, "sendingTime") == 0) return base+8;
    if (fieldName[0] == 't' && strcmp(fieldName, "timestamp") == 0) return base+9;
    if (fieldName[0] == 's' && strcmp(fieldName, "senderModuleId") == 0) return base+10;
    if (fieldName[0] == 's' && strcmp(fieldName, "senderGateId") == 0) return base+11;
    if (fieldName[0] == 's' && strcmp(fieldName, "senderModule") == 0) return base+12;
    if (fieldName[0] == 's' && strcmp(fieldName, "senderGate") == 0) return base+13;
    if (fieldName[0] == 'a' && strcmp(fieldName, "arrivalModuleId") == 0) return base+14;
    if (fieldName[0] == 'a' && strcmp(fieldName, "arrivalGateId") == 0) return base+15;
    if (fieldName[0] == 'a' && strcmp(fieldName, "arrivalModule") == 0) return base+16;
    if (fieldName[0] == 'a' && strcmp(fieldName, "arrivalGate") == 0) return base+17;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cMessageDescriptor::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[] = {
        "long",    // FIELD_id
        "long",    // FIELD_treeId
        "short",    // FIELD_kind
        "string",    // FIELD_displayString
        "omnetpp::cObject",    // FIELD_controlInfo
        "omnetpp::cArray",    // FIELD_parList
        "bool",    // FIELD_isSelfMessage
        "omnetpp::simtime_t",    // FIELD_creationTime
        "omnetpp::simtime_t",    // FIELD_sendingTime
        "omnetpp::simtime_t",    // FIELD_timestamp
        "int",    // FIELD_senderModuleId
        "int",    // FIELD_senderGateId
        "omnetpp::cModule",    // FIELD_senderModule
        "omnetpp::cGate",    // FIELD_senderGate
        "int",    // FIELD_arrivalModuleId
        "int",    // FIELD_arrivalGateId
        "omnetpp::cModule",    // FIELD_arrivalModule
        "omnetpp::cGate",    // FIELD_arrivalGate
    };
    return (field >= 0 && field < 18) ? fieldTypeStrings[field] : nullptr;
}

const char **cMessageDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_id: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_treeId: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_kind: {
            static const char *names[] = { "group", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_displayString: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_controlInfo: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_parList: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isSelfMessage: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_creationTime: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_sendingTime: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_timestamp: {
            static const char *names[] = { "group", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_senderModuleId: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_senderGateId: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_senderModule: {
            static const char *names[] = { "group", "hint", "eventlog",  nullptr };
            return names;
        }
        case FIELD_senderGate: {
            static const char *names[] = { "group", "hint", "eventlog",  nullptr };
            return names;
        }
        case FIELD_arrivalModuleId: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_arrivalGateId: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_arrivalModule: {
            static const char *names[] = { "group", "hint", "eventlog",  nullptr };
            return names;
        }
        case FIELD_arrivalGate: {
            static const char *names[] = { "group", "hint", "eventlog",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cMessageDescriptor::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 FIELD_id:
            if (!strcmp(propertyname, "group")) return "message";
            if (!strcmp(propertyname, "hint")) return "Automatically assigned unique identifier";
            return nullptr;
        case FIELD_treeId:
            if (!strcmp(propertyname, "group")) return "message";
            if (!strcmp(propertyname, "hint")) return "Identifier shared between the message and its copies";
            return nullptr;
        case FIELD_kind:
            if (!strcmp(propertyname, "group")) return "message";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "Generic user-settable attribute, usually carries \"type\" or \"role\" or \"category\" of message";
            return nullptr;
        case FIELD_displayString:
            if (!strcmp(propertyname, "group")) return "message";
            if (!strcmp(propertyname, "hint")) return "Controls appearance of the message in GUI";
            return nullptr;
        case FIELD_controlInfo:
            if (!strcmp(propertyname, "hint")) return "Used with protocol stacks: carries extra information when a packet is sent between protocol layers";
            return nullptr;
        case FIELD_parList:
            if (!strcmp(propertyname, "getter")) return "getParListPtr";
            if (!strcmp(propertyname, "group")) return "message";
            if (!strcmp(propertyname, "hint")) return "OBSOLETE: use of \"parList\" should be replaced with message subclassing in the few models that still use it";
            return nullptr;
        case FIELD_isSelfMessage:
            if (!strcmp(propertyname, "getter")) return "isSelfMessage";
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Whether message is a self-message, scheduled to be delivered back to the same module at a later time";
            return nullptr;
        case FIELD_creationTime:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Simulation time the message was created";
            return nullptr;
        case FIELD_sendingTime:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Simulation time of the current or last sending/scheduling of the message";
            return nullptr;
        case FIELD_timestamp:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "User-settable timestamp for generic use";
            return nullptr;
        case FIELD_senderModuleId:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "ID of the module performing the current or last send/schedule operation";
            return nullptr;
        case FIELD_senderGateId:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Module-local ID of the gate on which the message was sent out -- -1==none for self-messages and after \"sendDirect\"";
            return nullptr;
        case FIELD_senderModule:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "ID of the module performing the current or last send/schedule operation";
            if (!strcmp(propertyname, "eventlog")) return "fullPath";
            return nullptr;
        case FIELD_senderGate:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "The gate on which the message was sent out -- nullptr for self-messages and after \"sendDirect\"";
            if (!strcmp(propertyname, "eventlog")) return "fullName";
            return nullptr;
        case FIELD_arrivalModuleId:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "ID of the arrival module of the current or last sending/scheduling";
            return nullptr;
        case FIELD_arrivalGateId:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Module-local ID of arrival gate for current or last sending -- -1==none for self-messages";
            return nullptr;
        case FIELD_arrivalModule:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Arrival module for current or last sending/scheduling";
            if (!strcmp(propertyname, "eventlog")) return "fullPath";
            return nullptr;
        case FIELD_arrivalGate:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Arrival gate for current or last sending -- nullptr for self-messages";
            if (!strcmp(propertyname, "eventlog")) return "fullName";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cMessageDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cMessage *pp = (cMessage *)object; (void)pp;
    switch (field) {
        case FIELD_controlInfo: { const cObject * value = pp->getControlInfo(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_parList: { const cArray * value = pp->getParListPtr(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_senderModule: { const cModule * value = pp->getSenderModule(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_senderGate: { const cGate * value = pp->getSenderGate(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_arrivalModule: { const cModule * value = pp->getArrivalModule(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_arrivalGate: { const cGate * value = pp->getArrivalGate(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cMessageDescriptor::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();
    }
    cMessage *pp = (cMessage *)object; (void)pp;
    switch (field) {
        case FIELD_id: return long2string(pp->getId());
        case FIELD_treeId: return long2string(pp->getTreeId());
        case FIELD_kind: return long2string(pp->getKind());
        case FIELD_displayString: return oppstring2string(pp->getDisplayString());
        case FIELD_controlInfo: {std::stringstream out; out << pp->getControlInfo(); return out.str();}
        case FIELD_parList: {std::stringstream out; out << pp->getParListPtr(); return out.str();}
        case FIELD_isSelfMessage: return bool2string(pp->isSelfMessage());
        case FIELD_creationTime: return simtime2string(pp->getCreationTime());
        case FIELD_sendingTime: return simtime2string(pp->getSendingTime());
        case FIELD_timestamp: return simtime2string(pp->getTimestamp());
        case FIELD_senderModuleId: return long2string(pp->getSenderModuleId());
        case FIELD_senderGateId: return long2string(pp->getSenderGateId());
        case FIELD_senderModule: {std::stringstream out; out << pp->getSenderModule(); return out.str();}
        case FIELD_senderGate: {std::stringstream out; out << pp->getSenderGate(); return out.str();}
        case FIELD_arrivalModuleId: return long2string(pp->getArrivalModuleId());
        case FIELD_arrivalGateId: return long2string(pp->getArrivalGateId());
        case FIELD_arrivalModule: {std::stringstream out; out << pp->getArrivalModule(); return out.str();}
        case FIELD_arrivalGate: {std::stringstream out; out << pp->getArrivalGate(); return out.str();}
        default: return "";
    }
}

bool cMessageDescriptor::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();
    }
    cMessage *pp = (cMessage *)object; (void)pp;
    switch (field) {
        case FIELD_kind: pp->setKind(string2long(value)); return true;
        case FIELD_timestamp: pp->setTimestamp(string2simtime(value)); return true;
        default: return false;
    }
}

const char *cMessageDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_controlInfo: return omnetpp::opp_typename(typeid(cObject));
        case FIELD_parList: return omnetpp::opp_typename(typeid(cArray));
        case FIELD_senderModule: return omnetpp::opp_typename(typeid(cModule));
        case FIELD_senderGate: return omnetpp::opp_typename(typeid(cGate));
        case FIELD_arrivalModule: return omnetpp::opp_typename(typeid(cModule));
        case FIELD_arrivalGate: return omnetpp::opp_typename(typeid(cGate));
        default: return nullptr;
    };
}

void *cMessageDescriptor::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();
    }
    cMessage *pp = (cMessage *)object; (void)pp;
    switch (field) {
        case FIELD_controlInfo: return toVoidPtr(pp->getControlInfo()); break;
        case FIELD_parList: return toVoidPtr(pp->getParListPtr()); break;
        case FIELD_senderModule: return toVoidPtr(pp->getSenderModule()); break;
        case FIELD_senderGate: return toVoidPtr(pp->getSenderGate()); break;
        case FIELD_arrivalModule: return toVoidPtr(pp->getArrivalModule()); break;
        case FIELD_arrivalGate: return toVoidPtr(pp->getArrivalGate()); break;
        default: return nullptr;
    }
}

class cPacketDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_bitLength,
        FIELD_byteLength,
        FIELD_hasBitError,
        FIELD_encapsulatedPacket,
        FIELD_isReceptionStart,
        FIELD_duration,
    };
  public:
    cPacketDescriptor();
    virtual ~cPacketDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPacketDescriptor)

cPacketDescriptor::cPacketDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPacket)), "omnetpp::cMessage")
{
    propertynames = nullptr;
}

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

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

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

const char *cPacketDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "packet";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cPacketDescriptor::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,    // FIELD_bitLength
        FD_ISEDITABLE,    // FIELD_byteLength
        FD_ISEDITABLE,    // FIELD_hasBitError
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_encapsulatedPacket
        0,    // FIELD_isReceptionStart
        0,    // FIELD_duration
    };
    return (field >= 0 && field < 6) ? fieldTypeFlags[field] : 0;
}

const char *cPacketDescriptor::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[] = {
        "bitLength",
        "byteLength",
        "hasBitError",
        "encapsulatedPacket",
        "isReceptionStart",
        "duration",
    };
    return (field >= 0 && field < 6) ? fieldNames[field] : nullptr;
}

int cPacketDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'b' && strcmp(fieldName, "bitLength") == 0) return base+0;
    if (fieldName[0] == 'b' && strcmp(fieldName, "byteLength") == 0) return base+1;
    if (fieldName[0] == 'h' && strcmp(fieldName, "hasBitError") == 0) return base+2;
    if (fieldName[0] == 'e' && strcmp(fieldName, "encapsulatedPacket") == 0) return base+3;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isReceptionStart") == 0) return base+4;
    if (fieldName[0] == 'd' && strcmp(fieldName, "duration") == 0) return base+5;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cPacketDescriptor::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[] = {
        "int64_t",    // FIELD_bitLength
        "int64_t",    // FIELD_byteLength
        "bool",    // FIELD_hasBitError
        "omnetpp::cPacket",    // FIELD_encapsulatedPacket
        "bool",    // FIELD_isReceptionStart
        "omnetpp::simtime_t",    // FIELD_duration
    };
    return (field >= 0 && field < 6) ? fieldTypeStrings[field] : nullptr;
}

const char **cPacketDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_bitLength: {
            static const char *names[] = { "group", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_byteLength: {
            static const char *names[] = { "group", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_hasBitError: {
            static const char *names[] = { "getter", "group", "setter", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_encapsulatedPacket: {
            static const char *names[] = { "packetData", "hint",  nullptr };
            return names;
        }
        case FIELD_isReceptionStart: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_duration: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cPacketDescriptor::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 FIELD_bitLength:
            if (!strcmp(propertyname, "group")) return "packet";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "Simulated length of the message in bits, affects transmission time and probability of bit errors when sent through a channel";
            return nullptr;
        case FIELD_byteLength:
            if (!strcmp(propertyname, "group")) return "packet";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "Length in bytes, i.e. length in bits divided by eight";
            return nullptr;
        case FIELD_hasBitError:
            if (!strcmp(propertyname, "getter")) return "hasBitError";
            if (!strcmp(propertyname, "group")) return "packet";
            if (!strcmp(propertyname, "setter")) return "setBitError";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "Indicates that a bit error occurred when the message was sent through a channel with nonzero bit error rate";
            return nullptr;
        case FIELD_encapsulatedPacket:
            if (!strcmp(propertyname, "packetData")) return "";
            if (!strcmp(propertyname, "hint")) return "Used with protocol stacks: stores an encapsulated higher-layer packet";
            return nullptr;
        case FIELD_isReceptionStart:
            if (!strcmp(propertyname, "getter")) return "isReceptionStart";
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "When duration is nonzero: whether this message represents the start or the end of the frame reception";
            return nullptr;
        case FIELD_duration:
            if (!strcmp(propertyname, "group")) return "sending";
            if (!strcmp(propertyname, "hint")) return "Transmission time over a channel with datarate";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cPacketDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPacket *pp = (cPacket *)object; (void)pp;
    switch (field) {
        case FIELD_encapsulatedPacket: { const cPacket * value = pp->getEncapsulatedPacket(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cPacketDescriptor::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();
    }
    cPacket *pp = (cPacket *)object; (void)pp;
    switch (field) {
        case FIELD_bitLength: return int642string(pp->getBitLength());
        case FIELD_byteLength: return int642string(pp->getByteLength());
        case FIELD_hasBitError: return bool2string(pp->hasBitError());
        case FIELD_encapsulatedPacket: {std::stringstream out; out << pp->getEncapsulatedPacket(); return out.str();}
        case FIELD_isReceptionStart: return bool2string(pp->isReceptionStart());
        case FIELD_duration: return simtime2string(pp->getDuration());
        default: return "";
    }
}

bool cPacketDescriptor::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();
    }
    cPacket *pp = (cPacket *)object; (void)pp;
    switch (field) {
        case FIELD_bitLength: pp->setBitLength(string2int64(value)); return true;
        case FIELD_byteLength: pp->setByteLength(string2int64(value)); return true;
        case FIELD_hasBitError: pp->setBitError(string2bool(value)); return true;
        default: return false;
    }
}

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

void *cPacketDescriptor::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();
    }
    cPacket *pp = (cPacket *)object; (void)pp;
    switch (field) {
        case FIELD_encapsulatedPacket: return toVoidPtr(pp->getEncapsulatedPacket()); break;
        default: return nullptr;
    }
}

class cRNGDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cRNGDescriptor();
    virtual ~cRNGDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cRNGDescriptor)

cRNGDescriptor::cRNGDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cRNG)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cRNGDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cRNGDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cRNG *pp = (cRNG *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cRandomDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_rng,
    };
  public:
    cRandomDescriptor();
    virtual ~cRandomDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cRandomDescriptor)

cRandomDescriptor::cRandomDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cRandom)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cRandomDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "cogwheel";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cRandomDescriptor::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_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_rng
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

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

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

const char *cRandomDescriptor::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[] = {
        "omnetpp::cRNG",    // FIELD_rng
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cRandomDescriptor::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 FIELD_rng:
            if (!strcmp(propertyname, "getter")) return "getRNG";
            if (!strcmp(propertyname, "setter")) return "setRNG";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cRandomDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cRandom *pp = (cRandom *)object; (void)pp;
    switch (field) {
        case FIELD_rng: { const cRNG * value = pp->getRNG(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cRandomDescriptor::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();
    }
    cRandom *pp = (cRandom *)object; (void)pp;
    switch (field) {
        case FIELD_rng: {std::stringstream out; out << pp->getRNG(); return out.str();}
        default: return "";
    }
}

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

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

void *cRandomDescriptor::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();
    }
    cRandom *pp = (cRandom *)object; (void)pp;
    switch (field) {
        case FIELD_rng: return toVoidPtr(pp->getRNG()); break;
        default: return nullptr;
    }
}

class cUniformDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_a,
        FIELD_b,
    };
  public:
    cUniformDescriptor();
    virtual ~cUniformDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cUniformDescriptor)

cUniformDescriptor::cUniformDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cUniform)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cUniformDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cUniformDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cUniform *pp = (cUniform *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cUniformDescriptor::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();
    }
    cUniform *pp = (cUniform *)object; (void)pp;
    switch (field) {
        case FIELD_a: return double2string(pp->getA());
        case FIELD_b: return double2string(pp->getB());
        default: return "";
    }
}

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

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

class cExponentialDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_mean,
    };
  public:
    cExponentialDescriptor();
    virtual ~cExponentialDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cExponentialDescriptor)

cExponentialDescriptor::cExponentialDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cExponential)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cExponentialDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cExponentialDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cExponential *pp = (cExponential *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cExponentialDescriptor::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();
    }
    cExponential *pp = (cExponential *)object; (void)pp;
    switch (field) {
        case FIELD_mean: return double2string(pp->getMean());
        default: return "";
    }
}

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

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

class cNormalDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_mean,
        FIELD_stddev,
    };
  public:
    cNormalDescriptor();
    virtual ~cNormalDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cNormalDescriptor)

cNormalDescriptor::cNormalDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cNormal)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cNormalDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cNormalDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cNormal *pp = (cNormal *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cNormalDescriptor::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();
    }
    cNormal *pp = (cNormal *)object; (void)pp;
    switch (field) {
        case FIELD_mean: return double2string(pp->getMean());
        case FIELD_stddev: return double2string(pp->getStddev());
        default: return "";
    }
}

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

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

class cTruncNormalDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_mean,
        FIELD_stddev,
    };
  public:
    cTruncNormalDescriptor();
    virtual ~cTruncNormalDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cTruncNormalDescriptor)

cTruncNormalDescriptor::cTruncNormalDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cTruncNormal)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cTruncNormalDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cTruncNormalDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cTruncNormal *pp = (cTruncNormal *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cTruncNormalDescriptor::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();
    }
    cTruncNormal *pp = (cTruncNormal *)object; (void)pp;
    switch (field) {
        case FIELD_mean: return double2string(pp->getMean());
        case FIELD_stddev: return double2string(pp->getStddev());
        default: return "";
    }
}

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

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

class cGammaDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_alpha,
        FIELD_theta,
    };
  public:
    cGammaDescriptor();
    virtual ~cGammaDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cGammaDescriptor)

cGammaDescriptor::cGammaDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cGamma)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cGammaDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cGammaDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cGamma *pp = (cGamma *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cGammaDescriptor::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();
    }
    cGamma *pp = (cGamma *)object; (void)pp;
    switch (field) {
        case FIELD_alpha: return double2string(pp->getAlpha());
        case FIELD_theta: return double2string(pp->getTheta());
        default: return "";
    }
}

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

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

class cBetaDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_alpha1,
        FIELD_alpha2,
    };
  public:
    cBetaDescriptor();
    virtual ~cBetaDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cBetaDescriptor)

cBetaDescriptor::cBetaDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cBeta)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cBetaDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cBetaDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cBeta *pp = (cBeta *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cBetaDescriptor::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();
    }
    cBeta *pp = (cBeta *)object; (void)pp;
    switch (field) {
        case FIELD_alpha1: return double2string(pp->getAlpha1());
        case FIELD_alpha2: return double2string(pp->getAlpha2());
        default: return "";
    }
}

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

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

class cErlangDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_k,
        FIELD_mean,
    };
  public:
    cErlangDescriptor();
    virtual ~cErlangDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cErlangDescriptor)

cErlangDescriptor::cErlangDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cErlang)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cErlangDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

const char *cErlangDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    static const char *fieldTypeStrings[] = {
        "unsigned int",    // FIELD_k
        "double",    // FIELD_mean
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cErlangDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cErlang *pp = (cErlang *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cErlangDescriptor::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();
    }
    cErlang *pp = (cErlang *)object; (void)pp;
    switch (field) {
        case FIELD_k: return ulong2string(pp->getK());
        case FIELD_mean: return double2string(pp->getMean());
        default: return "";
    }
}

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

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

class cChiSquareDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_k,
    };
  public:
    cChiSquareDescriptor();
    virtual ~cChiSquareDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cChiSquareDescriptor)

cChiSquareDescriptor::cChiSquareDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cChiSquare)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cChiSquareDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cChiSquareDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cChiSquare *pp = (cChiSquare *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cChiSquareDescriptor::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();
    }
    cChiSquare *pp = (cChiSquare *)object; (void)pp;
    switch (field) {
        case FIELD_k: return ulong2string(pp->getK());
        default: return "";
    }
}

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

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

class cStudentTDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_i,
    };
  public:
    cStudentTDescriptor();
    virtual ~cStudentTDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cStudentTDescriptor)

cStudentTDescriptor::cStudentTDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cStudentT)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cStudentTDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cStudentTDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cStudentT *pp = (cStudentT *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cStudentTDescriptor::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();
    }
    cStudentT *pp = (cStudentT *)object; (void)pp;
    switch (field) {
        case FIELD_i: return ulong2string(pp->getI());
        default: return "";
    }
}

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

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

class cCauchyDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_a,
        FIELD_b,
    };
  public:
    cCauchyDescriptor();
    virtual ~cCauchyDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cCauchyDescriptor)

cCauchyDescriptor::cCauchyDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cCauchy)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cCauchyDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cCauchyDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cCauchy *pp = (cCauchy *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cCauchyDescriptor::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();
    }
    cCauchy *pp = (cCauchy *)object; (void)pp;
    switch (field) {
        case FIELD_a: return double2string(pp->getA());
        case FIELD_b: return double2string(pp->getB());
        default: return "";
    }
}

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

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

class cTriangDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_a,
        FIELD_b,
        FIELD_c,
    };
  public:
    cTriangDescriptor();
    virtual ~cTriangDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cTriangDescriptor)

cTriangDescriptor::cTriangDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cTriang)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cTriangDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cTriangDescriptor::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[] = {
        0,    // FIELD_a
        0,    // FIELD_b
        0,    // FIELD_c
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cTriangDescriptor::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[] = {
        "a",
        "b",
        "c",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

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

const char *cTriangDescriptor::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[] = {
        "double",    // FIELD_a
        "double",    // FIELD_b
        "double",    // FIELD_c
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cTriangDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cTriang *pp = (cTriang *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cTriangDescriptor::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();
    }
    cTriang *pp = (cTriang *)object; (void)pp;
    switch (field) {
        case FIELD_a: return double2string(pp->getA());
        case FIELD_b: return double2string(pp->getB());
        case FIELD_c: return double2string(pp->getC());
        default: return "";
    }
}

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

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

class cWeibullDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_a,
        FIELD_b,
    };
  public:
    cWeibullDescriptor();
    virtual ~cWeibullDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cWeibullDescriptor)

cWeibullDescriptor::cWeibullDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cWeibull)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cWeibullDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cWeibullDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cWeibull *pp = (cWeibull *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cWeibullDescriptor::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();
    }
    cWeibull *pp = (cWeibull *)object; (void)pp;
    switch (field) {
        case FIELD_a: return double2string(pp->getA());
        case FIELD_b: return double2string(pp->getB());
        default: return "";
    }
}

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

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

class cParetoShiftedDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_a,
        FIELD_b,
        FIELD_c,
    };
  public:
    cParetoShiftedDescriptor();
    virtual ~cParetoShiftedDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cParetoShiftedDescriptor)

cParetoShiftedDescriptor::cParetoShiftedDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cParetoShifted)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cParetoShiftedDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cParetoShiftedDescriptor::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[] = {
        0,    // FIELD_a
        0,    // FIELD_b
        0,    // FIELD_c
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cParetoShiftedDescriptor::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[] = {
        "a",
        "b",
        "c",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

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

const char *cParetoShiftedDescriptor::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[] = {
        "double",    // FIELD_a
        "double",    // FIELD_b
        "double",    // FIELD_c
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cParetoShiftedDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cParetoShifted *pp = (cParetoShifted *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cParetoShiftedDescriptor::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();
    }
    cParetoShifted *pp = (cParetoShifted *)object; (void)pp;
    switch (field) {
        case FIELD_a: return double2string(pp->getA());
        case FIELD_b: return double2string(pp->getB());
        case FIELD_c: return double2string(pp->getC());
        default: return "";
    }
}

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

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

class cIntUniformDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_a,
        FIELD_b,
    };
  public:
    cIntUniformDescriptor();
    virtual ~cIntUniformDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cIntUniformDescriptor)

cIntUniformDescriptor::cIntUniformDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cIntUniform)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cIntUniformDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cIntUniformDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cIntUniform *pp = (cIntUniform *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cIntUniformDescriptor::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();
    }
    cIntUniform *pp = (cIntUniform *)object; (void)pp;
    switch (field) {
        case FIELD_a: return long2string(pp->getA());
        case FIELD_b: return long2string(pp->getB());
        default: return "";
    }
}

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

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

class cBernoulliDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_p,
    };
  public:
    cBernoulliDescriptor();
    virtual ~cBernoulliDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cBernoulliDescriptor)

cBernoulliDescriptor::cBernoulliDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cBernoulli)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cBernoulliDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cBernoulliDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cBernoulli *pp = (cBernoulli *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cBernoulliDescriptor::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();
    }
    cBernoulli *pp = (cBernoulli *)object; (void)pp;
    switch (field) {
        case FIELD_p: return double2string(pp->getP());
        default: return "";
    }
}

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

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

class cBinomialDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_n,
        FIELD_p,
    };
  public:
    cBinomialDescriptor();
    virtual ~cBinomialDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cBinomialDescriptor)

cBinomialDescriptor::cBinomialDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cBinomial)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cBinomialDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

const char *cBinomialDescriptor::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[] = {
        "int",    // FIELD_n
        "double",    // FIELD_p
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cBinomialDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cBinomial *pp = (cBinomial *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cBinomialDescriptor::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();
    }
    cBinomial *pp = (cBinomial *)object; (void)pp;
    switch (field) {
        case FIELD_n: return long2string(pp->getN());
        case FIELD_p: return double2string(pp->getP());
        default: return "";
    }
}

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

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

class cGeometricDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_p,
    };
  public:
    cGeometricDescriptor();
    virtual ~cGeometricDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cGeometricDescriptor)

cGeometricDescriptor::cGeometricDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cGeometric)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cGeometricDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cGeometricDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cGeometric *pp = (cGeometric *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cGeometricDescriptor::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();
    }
    cGeometric *pp = (cGeometric *)object; (void)pp;
    switch (field) {
        case FIELD_p: return double2string(pp->getP());
        default: return "";
    }
}

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

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

class cNegBinomialDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_n,
        FIELD_p,
    };
  public:
    cNegBinomialDescriptor();
    virtual ~cNegBinomialDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cNegBinomialDescriptor)

cNegBinomialDescriptor::cNegBinomialDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cNegBinomial)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cNegBinomialDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

const char *cNegBinomialDescriptor::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[] = {
        "int",    // FIELD_n
        "double",    // FIELD_p
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cNegBinomialDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cNegBinomial *pp = (cNegBinomial *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cNegBinomialDescriptor::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();
    }
    cNegBinomial *pp = (cNegBinomial *)object; (void)pp;
    switch (field) {
        case FIELD_n: return long2string(pp->getN());
        case FIELD_p: return double2string(pp->getP());
        default: return "";
    }
}

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

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

class cPoissonDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_lambda,
    };
  public:
    cPoissonDescriptor();
    virtual ~cPoissonDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPoissonDescriptor)

cPoissonDescriptor::cPoissonDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPoisson)), "omnetpp::cRandom")
{
    propertynames = nullptr;
}

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

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

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

const char *cPoissonDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cPoissonDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPoisson *pp = (cPoisson *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPoissonDescriptor::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();
    }
    cPoisson *pp = (cPoisson *)object; (void)pp;
    switch (field) {
        case FIELD_lambda: return double2string(pp->getLambda());
        default: return "";
    }
}

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

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

class cStatisticDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_count,
        FIELD_sumWeights,
        FIELD_min,
        FIELD_max,
        FIELD_mean,
        FIELD_stddev,
        FIELD_variance,
    };
  public:
    cStatisticDescriptor();
    virtual ~cStatisticDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cStatisticDescriptor)

cStatisticDescriptor::cStatisticDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cStatistic)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cStatisticDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "statistic";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cStatisticDescriptor::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[] = {
        0,    // FIELD_count
        0,    // FIELD_sumWeights
        0,    // FIELD_min
        0,    // FIELD_max
        0,    // FIELD_mean
        0,    // FIELD_stddev
        0,    // FIELD_variance
    };
    return (field >= 0 && field < 7) ? fieldTypeFlags[field] : 0;
}

const char *cStatisticDescriptor::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[] = {
        "count",
        "sumWeights",
        "min",
        "max",
        "mean",
        "stddev",
        "variance",
    };
    return (field >= 0 && field < 7) ? fieldNames[field] : nullptr;
}

int cStatisticDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "count") == 0) return base+0;
    if (fieldName[0] == 's' && strcmp(fieldName, "sumWeights") == 0) return base+1;
    if (fieldName[0] == 'm' && strcmp(fieldName, "min") == 0) return base+2;
    if (fieldName[0] == 'm' && strcmp(fieldName, "max") == 0) return base+3;
    if (fieldName[0] == 'm' && strcmp(fieldName, "mean") == 0) return base+4;
    if (fieldName[0] == 's' && strcmp(fieldName, "stddev") == 0) return base+5;
    if (fieldName[0] == 'v' && strcmp(fieldName, "variance") == 0) return base+6;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cStatisticDescriptor::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[] = {
        "long",    // FIELD_count
        "double",    // FIELD_sumWeights
        "double",    // FIELD_min
        "double",    // FIELD_max
        "double",    // FIELD_mean
        "double",    // FIELD_stddev
        "double",    // FIELD_variance
    };
    return (field >= 0 && field < 7) ? fieldTypeStrings[field] : nullptr;
}

const char **cStatisticDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_count: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_sumWeights: {
            static const char *names[] = { "group", "getter", "hint",  nullptr };
            return names;
        }
        case FIELD_min: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_max: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_mean: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_stddev: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_variance: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cStatisticDescriptor::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 FIELD_count:
            if (!strcmp(propertyname, "group")) return "statistical summary";
            if (!strcmp(propertyname, "hint")) return "Number of observations collected, regardless of their weights";
            return nullptr;
        case FIELD_sumWeights:
            if (!strcmp(propertyname, "group")) return "statistical summary";
            if (!strcmp(propertyname, "getter")) return "getWeights";
            if (!strcmp(propertyname, "hint")) return "Sum of weights, which equals the number of observations in the unweighted case";
            return nullptr;
        case FIELD_min:
            if (!strcmp(propertyname, "group")) return "statistical summary";
            if (!strcmp(propertyname, "hint")) return "Minimum of the observations";
            return nullptr;
        case FIELD_max:
            if (!strcmp(propertyname, "group")) return "statistical summary";
            if (!strcmp(propertyname, "hint")) return "Maximum of the observations";
            return nullptr;
        case FIELD_mean:
            if (!strcmp(propertyname, "group")) return "statistical summary";
            if (!strcmp(propertyname, "hint")) return "Mean of the observations";
            return nullptr;
        case FIELD_stddev:
            if (!strcmp(propertyname, "group")) return "statistical summary";
            if (!strcmp(propertyname, "hint")) return "Standard deviation of the observations";
            return nullptr;
        case FIELD_variance:
            if (!strcmp(propertyname, "group")) return "statistical summary";
            if (!strcmp(propertyname, "hint")) return "Variance of the observations";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cStatisticDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cStatistic *pp = (cStatistic *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cStatisticDescriptor::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();
    }
    cStatistic *pp = (cStatistic *)object; (void)pp;
    switch (field) {
        case FIELD_count: return long2string(pp->getCount());
        case FIELD_sumWeights: return double2string(pp->getWeights());
        case FIELD_min: return double2string(pp->getMin());
        case FIELD_max: return double2string(pp->getMax());
        case FIELD_mean: return double2string(pp->getMean());
        case FIELD_stddev: return double2string(pp->getStddev());
        case FIELD_variance: return double2string(pp->getVariance());
        default: return "";
    }
}

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

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

class cStdDevDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cStdDevDescriptor();
    virtual ~cStdDevDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cStdDevDescriptor)

cStdDevDescriptor::cStdDevDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cStdDev)), "omnetpp::cStatistic")
{
    propertynames = nullptr;
}

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

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

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

const char *cStdDevDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cStdDevDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cStdDev *pp = (cStdDev *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cWeightedStdDevDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cWeightedStdDevDescriptor();
    virtual ~cWeightedStdDevDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cWeightedStdDevDescriptor)

cWeightedStdDevDescriptor::cWeightedStdDevDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cWeightedStdDev)), "omnetpp::cStdDev")
{
    propertynames = nullptr;
}

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

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

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

const char *cWeightedStdDevDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cWeightedStdDevDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cWeightedStdDev *pp = (cWeightedStdDev *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cAbstractHistogramDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_binsAlreadySetUp,
        FIELD_underflowSumWeights,
        FIELD_overflowSumWeights,
        FIELD_numBins,
        FIELD_binInfo,
    };
  public:
    cAbstractHistogramDescriptor();
    virtual ~cAbstractHistogramDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cAbstractHistogramDescriptor)

cAbstractHistogramDescriptor::cAbstractHistogramDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cAbstractHistogram)), "omnetpp::cStdDev")
{
    propertynames = nullptr;
}

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

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

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

const char *cAbstractHistogramDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cAbstractHistogramDescriptor::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[] = {
        0,    // FIELD_binsAlreadySetUp
        0,    // FIELD_underflowSumWeights
        0,    // FIELD_overflowSumWeights
        0,    // FIELD_numBins
        FD_ISARRAY,    // FIELD_binInfo
    };
    return (field >= 0 && field < 5) ? fieldTypeFlags[field] : 0;
}

const char *cAbstractHistogramDescriptor::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[] = {
        "binsAlreadySetUp",
        "underflowSumWeights",
        "overflowSumWeights",
        "numBins",
        "binInfo",
    };
    return (field >= 0 && field < 5) ? fieldNames[field] : nullptr;
}

int cAbstractHistogramDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'b' && strcmp(fieldName, "binsAlreadySetUp") == 0) return base+0;
    if (fieldName[0] == 'u' && strcmp(fieldName, "underflowSumWeights") == 0) return base+1;
    if (fieldName[0] == 'o' && strcmp(fieldName, "overflowSumWeights") == 0) return base+2;
    if (fieldName[0] == 'n' && strcmp(fieldName, "numBins") == 0) return base+3;
    if (fieldName[0] == 'b' && strcmp(fieldName, "binInfo") == 0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cAbstractHistogramDescriptor::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[] = {
        "bool",    // FIELD_binsAlreadySetUp
        "double",    // FIELD_underflowSumWeights
        "double",    // FIELD_overflowSumWeights
        "int",    // FIELD_numBins
        "omnetpp::cAbstractHistogram::Bin",    // FIELD_binInfo
    };
    return (field >= 0 && field < 5) ? fieldTypeStrings[field] : nullptr;
}

const char **cAbstractHistogramDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_binsAlreadySetUp: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_underflowSumWeights: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_overflowSumWeights: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_numBins: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_binInfo: {
            static const char *names[] = { "getter", "sizeGetter", "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cAbstractHistogramDescriptor::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 FIELD_binsAlreadySetUp:
            if (!strcmp(propertyname, "getter")) return "binsAlreadySetUp";
            if (!strcmp(propertyname, "group")) return "histogram";
            if (!strcmp(propertyname, "hint")) return "If false, the object is still collecting initial observations to gather information for laying out histogram bins";
            return nullptr;
        case FIELD_underflowSumWeights:
            if (!strcmp(propertyname, "group")) return "histogram";
            if (!strcmp(propertyname, "hint")) return "Total weight of observations above the last histogram bin";
            return nullptr;
        case FIELD_overflowSumWeights:
            if (!strcmp(propertyname, "group")) return "histogram";
            if (!strcmp(propertyname, "hint")) return "Total weight of observations above the last histogram bin";
            return nullptr;
        case FIELD_numBins:
            if (!strcmp(propertyname, "group")) return "histogram";
            if (!strcmp(propertyname, "hint")) return "Number of bins in the histogram";
            return nullptr;
        case FIELD_binInfo:
            if (!strcmp(propertyname, "getter")) return "internalGetBinInfo";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumBins";
            if (!strcmp(propertyname, "group")) return "histogram";
            if (!strcmp(propertyname, "hint")) return "Histogram bin bounds, observation count in the bin, and density estimate in the bin";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cAbstractHistogramDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cAbstractHistogram *pp = (cAbstractHistogram *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cAbstractHistogramDescriptor::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();
    }
    cAbstractHistogram *pp = (cAbstractHistogram *)object; (void)pp;
    switch (field) {
        case FIELD_binsAlreadySetUp: return bool2string(pp->binsAlreadySetUp());
        case FIELD_underflowSumWeights: return double2string(pp->getUnderflowSumWeights());
        case FIELD_overflowSumWeights: return double2string(pp->getOverflowSumWeights());
        case FIELD_numBins: return long2string(pp->getNumBins());
        case FIELD_binInfo: {std::stringstream out; out << pp->internalGetBinInfo(i); return out.str();}
        default: return "";
    }
}

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

const char *cAbstractHistogramDescriptor::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 *cAbstractHistogramDescriptor::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();
    }
    cAbstractHistogram *pp = (cAbstractHistogram *)object; (void)pp;
    switch (field) {
        case FIELD_binInfo: return toVoidPtr(&pp->internalGetBinInfo(i)); break;
        default: return nullptr;
    }
}

class cHistogramDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_strategy,
    };
  public:
    cHistogramDescriptor();
    virtual ~cHistogramDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cHistogramDescriptor)

cHistogramDescriptor::cHistogramDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cHistogram)), "omnetpp::cAbstractHistogram")
{
    propertynames = nullptr;
}

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

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

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

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

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

unsigned int cHistogramDescriptor::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_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_strategy
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

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

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

const char *cHistogramDescriptor::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[] = {
        "omnetpp::cIHistogramStrategy",    // FIELD_strategy
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cHistogramDescriptor::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 FIELD_strategy:
            if (!strcmp(propertyname, "group")) return "histogram";
            if (!strcmp(propertyname, "hint")) return "Determines when and how bins are created";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cHistogramDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cHistogram *pp = (cHistogram *)object; (void)pp;
    switch (field) {
        case FIELD_strategy: { const cIHistogramStrategy * value = pp->getStrategy(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cHistogramDescriptor::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();
    }
    cHistogram *pp = (cHistogram *)object; (void)pp;
    switch (field) {
        case FIELD_strategy: {std::stringstream out; out << pp->getStrategy(); return out.str();}
        default: return "";
    }
}

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

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

void *cHistogramDescriptor::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();
    }
    cHistogram *pp = (cHistogram *)object; (void)pp;
    switch (field) {
        case FIELD_strategy: return toVoidPtr(pp->getStrategy()); break;
        default: return nullptr;
    }
}

class cIHistogramStrategyDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cIHistogramStrategyDescriptor();
    virtual ~cIHistogramStrategyDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cIHistogramStrategyDescriptor)

cIHistogramStrategyDescriptor::cIHistogramStrategyDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cIHistogramStrategy)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

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

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

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

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

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

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

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

const char *cIHistogramStrategyDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cIHistogramStrategy *pp = (cIHistogramStrategy *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cFixedRangeHistogramStrategyDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_lowerLimit,
        FIELD_upperLimit,
        FIELD_binSize,
        FIELD_mode,
    };
  public:
    cFixedRangeHistogramStrategyDescriptor();
    virtual ~cFixedRangeHistogramStrategyDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cFixedRangeHistogramStrategyDescriptor)

cFixedRangeHistogramStrategyDescriptor::cFixedRangeHistogramStrategyDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cFixedRangeHistogramStrategy)), "omnetpp::cIHistogramStrategy")
{
    propertynames = nullptr;
}

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

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

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

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

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

unsigned int cFixedRangeHistogramStrategyDescriptor::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,    // FIELD_lowerLimit
        FD_ISEDITABLE,    // FIELD_upperLimit
        FD_ISEDITABLE,    // FIELD_binSize
        FD_ISEDITABLE,    // FIELD_mode
    };
    return (field >= 0 && field < 4) ? fieldTypeFlags[field] : 0;
}

const char *cFixedRangeHistogramStrategyDescriptor::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[] = {
        "lowerLimit",
        "upperLimit",
        "binSize",
        "mode",
    };
    return (field >= 0 && field < 4) ? fieldNames[field] : nullptr;
}

int cFixedRangeHistogramStrategyDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lowerLimit") == 0) return base+0;
    if (fieldName[0] == 'u' && strcmp(fieldName, "upperLimit") == 0) return base+1;
    if (fieldName[0] == 'b' && strcmp(fieldName, "binSize") == 0) return base+2;
    if (fieldName[0] == 'm' && strcmp(fieldName, "mode") == 0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cFixedRangeHistogramStrategyDescriptor::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[] = {
        "double",    // FIELD_lowerLimit
        "double",    // FIELD_upperLimit
        "double",    // FIELD_binSize
        "int",    // FIELD_mode
    };
    return (field >= 0 && field < 4) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cFixedRangeHistogramStrategyDescriptor::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 FIELD_lowerLimit:
            if (!strcmp(propertyname, "hint")) return "Histogram range lower endpoint";
            return nullptr;
        case FIELD_upperLimit:
            if (!strcmp(propertyname, "hint")) return "Histogram range upper endpoint";
            return nullptr;
        case FIELD_mode:
            if (!strcmp(propertyname, "enum")) return "cHistogram::Mode";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cHistogram::Mode";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cFixedRangeHistogramStrategyDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cFixedRangeHistogramStrategy *pp = (cFixedRangeHistogramStrategy *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cFixedRangeHistogramStrategyDescriptor::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();
    }
    cFixedRangeHistogramStrategy *pp = (cFixedRangeHistogramStrategy *)object; (void)pp;
    switch (field) {
        case FIELD_lowerLimit: return double2string(pp->getLowerLimit());
        case FIELD_upperLimit: return double2string(pp->getUpperLimit());
        case FIELD_binSize: return double2string(pp->getBinSize());
        case FIELD_mode: return enum2string(pp->getMode(), "omnetpp::cHistogram::Mode");
        default: return "";
    }
}

bool cFixedRangeHistogramStrategyDescriptor::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();
    }
    cFixedRangeHistogramStrategy *pp = (cFixedRangeHistogramStrategy *)object; (void)pp;
    switch (field) {
        case FIELD_lowerLimit: pp->setLowerLimit(string2double(value)); return true;
        case FIELD_upperLimit: pp->setUpperLimit(string2double(value)); return true;
        case FIELD_binSize: pp->setBinSize(string2double(value)); return true;
        case FIELD_mode: pp->setMode((omnetpp::cHistogram::Mode)string2enum(value, "omnetpp::cHistogram::Mode")); return true;
        default: return false;
    }
}

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

class cPrecollectionBasedHistogramStrategyDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_numToPrecollect,
        FIELD_numToCollate,
        FIELD_rangeUnchangedThreshold,
    };
  public:
    cPrecollectionBasedHistogramStrategyDescriptor();
    virtual ~cPrecollectionBasedHistogramStrategyDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPrecollectionBasedHistogramStrategyDescriptor)

cPrecollectionBasedHistogramStrategyDescriptor::cPrecollectionBasedHistogramStrategyDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPrecollectionBasedHistogramStrategy)), "omnetpp::cIHistogramStrategy")
{
    propertynames = nullptr;
}

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

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

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

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

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

unsigned int cPrecollectionBasedHistogramStrategyDescriptor::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,    // FIELD_numToPrecollect
        FD_ISEDITABLE,    // FIELD_numToCollate
        FD_ISEDITABLE,    // FIELD_rangeUnchangedThreshold
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cPrecollectionBasedHistogramStrategyDescriptor::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[] = {
        "numToPrecollect",
        "numToCollate",
        "rangeUnchangedThreshold",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

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

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

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

const char *cPrecollectionBasedHistogramStrategyDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPrecollectionBasedHistogramStrategy *pp = (cPrecollectionBasedHistogramStrategy *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPrecollectionBasedHistogramStrategyDescriptor::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();
    }
    cPrecollectionBasedHistogramStrategy *pp = (cPrecollectionBasedHistogramStrategy *)object; (void)pp;
    switch (field) {
        case FIELD_numToPrecollect: return long2string(pp->getNumToPrecollect());
        case FIELD_numToCollate: return long2string(pp->getNumToCollate());
        case FIELD_rangeUnchangedThreshold: return long2string(pp->getRangeUnchangedThreshold());
        default: return "";
    }
}

bool cPrecollectionBasedHistogramStrategyDescriptor::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();
    }
    cPrecollectionBasedHistogramStrategy *pp = (cPrecollectionBasedHistogramStrategy *)object; (void)pp;
    switch (field) {
        case FIELD_numToPrecollect: pp->setNumToPrecollect(string2long(value)); return true;
        case FIELD_numToCollate: pp->setNumToCollate(string2long(value)); return true;
        case FIELD_rangeUnchangedThreshold: pp->setRangeUnchangedThreshold(string2long(value)); return true;
        default: return false;
    }
}

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

class cDefaultHistogramStrategyDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_numBinsHint,
    };
  public:
    cDefaultHistogramStrategyDescriptor();
    virtual ~cDefaultHistogramStrategyDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cDefaultHistogramStrategyDescriptor)

cDefaultHistogramStrategyDescriptor::cDefaultHistogramStrategyDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cDefaultHistogramStrategy)), "omnetpp::cPrecollectionBasedHistogramStrategy")
{
    propertynames = nullptr;
}

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

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

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

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

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

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

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

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

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

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

const char *cDefaultHistogramStrategyDescriptor::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 FIELD_numBinsHint:
            if (!strcmp(propertyname, "hint")) return "Desired number of bins";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cDefaultHistogramStrategyDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cDefaultHistogramStrategy *pp = (cDefaultHistogramStrategy *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cDefaultHistogramStrategyDescriptor::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();
    }
    cDefaultHistogramStrategy *pp = (cDefaultHistogramStrategy *)object; (void)pp;
    switch (field) {
        case FIELD_numBinsHint: return long2string(pp->getNumBinsHint());
        default: return "";
    }
}

bool cDefaultHistogramStrategyDescriptor::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();
    }
    cDefaultHistogramStrategy *pp = (cDefaultHistogramStrategy *)object; (void)pp;
    switch (field) {
        case FIELD_numBinsHint: pp->setNumBinsHint(string2long(value)); return true;
        default: return false;
    }
}

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

class cAutoRangeHistogramStrategyDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_lowerLimitHint,
        FIELD_upperLimitHint,
        FIELD_rangeExtensionFactor,
        FIELD_mode,
        FIELD_binSizeHint,
        FIELD_binSizeRounding,
        FIELD_numBinsHint,
        FIELD_autoExtend,
        FIELD_binMerging,
        FIELD_maxNumBins,
    };
  public:
    cAutoRangeHistogramStrategyDescriptor();
    virtual ~cAutoRangeHistogramStrategyDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cAutoRangeHistogramStrategyDescriptor)

cAutoRangeHistogramStrategyDescriptor::cAutoRangeHistogramStrategyDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cAutoRangeHistogramStrategy)), "omnetpp::cPrecollectionBasedHistogramStrategy")
{
    propertynames = nullptr;
}

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

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

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

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

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

unsigned int cAutoRangeHistogramStrategyDescriptor::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,    // FIELD_lowerLimitHint
        FD_ISEDITABLE,    // FIELD_upperLimitHint
        FD_ISEDITABLE,    // FIELD_rangeExtensionFactor
        FD_ISEDITABLE,    // FIELD_mode
        FD_ISEDITABLE,    // FIELD_binSizeHint
        FD_ISEDITABLE,    // FIELD_binSizeRounding
        FD_ISEDITABLE,    // FIELD_numBinsHint
        FD_ISEDITABLE,    // FIELD_autoExtend
        FD_ISEDITABLE,    // FIELD_binMerging
        FD_ISEDITABLE,    // FIELD_maxNumBins
    };
    return (field >= 0 && field < 10) ? fieldTypeFlags[field] : 0;
}

const char *cAutoRangeHistogramStrategyDescriptor::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[] = {
        "lowerLimitHint",
        "upperLimitHint",
        "rangeExtensionFactor",
        "mode",
        "binSizeHint",
        "binSizeRounding",
        "numBinsHint",
        "autoExtend",
        "binMerging",
        "maxNumBins",
    };
    return (field >= 0 && field < 10) ? fieldNames[field] : nullptr;
}

int cAutoRangeHistogramStrategyDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lowerLimitHint") == 0) return base+0;
    if (fieldName[0] == 'u' && strcmp(fieldName, "upperLimitHint") == 0) return base+1;
    if (fieldName[0] == 'r' && strcmp(fieldName, "rangeExtensionFactor") == 0) return base+2;
    if (fieldName[0] == 'm' && strcmp(fieldName, "mode") == 0) return base+3;
    if (fieldName[0] == 'b' && strcmp(fieldName, "binSizeHint") == 0) return base+4;
    if (fieldName[0] == 'b' && strcmp(fieldName, "binSizeRounding") == 0) return base+5;
    if (fieldName[0] == 'n' && strcmp(fieldName, "numBinsHint") == 0) return base+6;
    if (fieldName[0] == 'a' && strcmp(fieldName, "autoExtend") == 0) return base+7;
    if (fieldName[0] == 'b' && strcmp(fieldName, "binMerging") == 0) return base+8;
    if (fieldName[0] == 'm' && strcmp(fieldName, "maxNumBins") == 0) return base+9;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cAutoRangeHistogramStrategyDescriptor::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[] = {
        "double",    // FIELD_lowerLimitHint
        "double",    // FIELD_upperLimitHint
        "double",    // FIELD_rangeExtensionFactor
        "int",    // FIELD_mode
        "double",    // FIELD_binSizeHint
        "bool",    // FIELD_binSizeRounding
        "int",    // FIELD_numBinsHint
        "bool",    // FIELD_autoExtend
        "bool",    // FIELD_binMerging
        "int",    // FIELD_maxNumBins
    };
    return (field >= 0 && field < 10) ? fieldTypeStrings[field] : nullptr;
}

const char **cAutoRangeHistogramStrategyDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_lowerLimitHint: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_upperLimitHint: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_mode: {
            static const char *names[] = { "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_binSizeHint: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_numBinsHint: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cAutoRangeHistogramStrategyDescriptor::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 FIELD_lowerLimitHint:
            if (!strcmp(propertyname, "hint")) return "Histogram range lower endpoint";
            return nullptr;
        case FIELD_upperLimitHint:
            if (!strcmp(propertyname, "hint")) return "Histogram range upper endpoint";
            return nullptr;
        case FIELD_mode:
            if (!strcmp(propertyname, "enum")) return "cHistogram::Mode";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cHistogram::Mode";
            return nullptr;
        case FIELD_binSizeHint:
            if (!strcmp(propertyname, "hint")) return "Requested bin size";
            return nullptr;
        case FIELD_numBinsHint:
            if (!strcmp(propertyname, "hint")) return "Desired number of bins";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cAutoRangeHistogramStrategyDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cAutoRangeHistogramStrategy *pp = (cAutoRangeHistogramStrategy *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cAutoRangeHistogramStrategyDescriptor::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();
    }
    cAutoRangeHistogramStrategy *pp = (cAutoRangeHistogramStrategy *)object; (void)pp;
    switch (field) {
        case FIELD_lowerLimitHint: return double2string(pp->getLowerLimitHint());
        case FIELD_upperLimitHint: return double2string(pp->getUpperLimitHint());
        case FIELD_rangeExtensionFactor: return double2string(pp->getRangeExtensionFactor());
        case FIELD_mode: return enum2string(pp->getMode(), "omnetpp::cHistogram::Mode");
        case FIELD_binSizeHint: return double2string(pp->getBinSizeHint());
        case FIELD_binSizeRounding: return bool2string(pp->getBinSizeRounding());
        case FIELD_numBinsHint: return long2string(pp->getNumBinsHint());
        case FIELD_autoExtend: return bool2string(pp->getAutoExtend());
        case FIELD_binMerging: return bool2string(pp->getBinMerging());
        case FIELD_maxNumBins: return long2string(pp->getMaxNumBins());
        default: return "";
    }
}

bool cAutoRangeHistogramStrategyDescriptor::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();
    }
    cAutoRangeHistogramStrategy *pp = (cAutoRangeHistogramStrategy *)object; (void)pp;
    switch (field) {
        case FIELD_lowerLimitHint: pp->setLowerLimitHint(string2double(value)); return true;
        case FIELD_upperLimitHint: pp->setUpperLimitHint(string2double(value)); return true;
        case FIELD_rangeExtensionFactor: pp->setRangeExtensionFactor(string2double(value)); return true;
        case FIELD_mode: pp->setMode((omnetpp::cHistogram::Mode)string2enum(value, "omnetpp::cHistogram::Mode")); return true;
        case FIELD_binSizeHint: pp->setBinSizeHint(string2double(value)); return true;
        case FIELD_binSizeRounding: pp->setBinSizeRounding(string2bool(value)); return true;
        case FIELD_numBinsHint: pp->setNumBinsHint(string2long(value)); return true;
        case FIELD_autoExtend: pp->setAutoExtend(string2bool(value)); return true;
        case FIELD_binMerging: pp->setBinMerging(string2bool(value)); return true;
        case FIELD_maxNumBins: pp->setMaxNumBins(string2long(value)); return true;
        default: return false;
    }
}

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

class cPrecollectionBasedDensityEstDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cPrecollectionBasedDensityEstDescriptor();
    virtual ~cPrecollectionBasedDensityEstDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPrecollectionBasedDensityEstDescriptor)

cPrecollectionBasedDensityEstDescriptor::cPrecollectionBasedDensityEstDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPrecollectionBasedDensityEst)), "omnetpp::cAbstractHistogram")
{
    propertynames = nullptr;
}

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

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

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

const char *cPrecollectionBasedDensityEstDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cPrecollectionBasedDensityEstDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPrecollectionBasedDensityEst *pp = (cPrecollectionBasedDensityEst *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cLegacyHistogramBaseDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cLegacyHistogramBaseDescriptor();
    virtual ~cLegacyHistogramBaseDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cLegacyHistogramBaseDescriptor)

cLegacyHistogramBaseDescriptor::cLegacyHistogramBaseDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cLegacyHistogramBase)), "omnetpp::cPrecollectionBasedDensityEst")
{
    propertynames = nullptr;
}

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

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

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

const char *cLegacyHistogramBaseDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cLegacyHistogramBaseDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cLegacyHistogramBase *pp = (cLegacyHistogramBase *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cLegacyHistogramDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cLegacyHistogramDescriptor();
    virtual ~cLegacyHistogramDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cLegacyHistogramDescriptor)

cLegacyHistogramDescriptor::cLegacyHistogramDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cLegacyHistogram)), "omnetpp::cLegacyHistogramBase")
{
    propertynames = nullptr;
}

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

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

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

const char *cLegacyHistogramDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cLegacyHistogramDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cLegacyHistogram *pp = (cLegacyHistogram *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cVarHistogramDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cVarHistogramDescriptor();
    virtual ~cVarHistogramDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cVarHistogramDescriptor)

cVarHistogramDescriptor::cVarHistogramDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cVarHistogram)), "omnetpp::cLegacyHistogramBase")
{
    propertynames = nullptr;
}

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

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

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

const char *cVarHistogramDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cVarHistogramDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cVarHistogram *pp = (cVarHistogram *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cLongHistogramDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cLongHistogramDescriptor();
    virtual ~cLongHistogramDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cLongHistogramDescriptor)

cLongHistogramDescriptor::cLongHistogramDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cLongHistogram)), "omnetpp::cLegacyHistogram")
{
    propertynames = nullptr;
}

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

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

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

const char *cLongHistogramDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cLongHistogramDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cLongHistogram *pp = (cLongHistogram *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cDoubleHistogramDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cDoubleHistogramDescriptor();
    virtual ~cDoubleHistogramDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cDoubleHistogramDescriptor)

cDoubleHistogramDescriptor::cDoubleHistogramDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cDoubleHistogram)), "omnetpp::cLegacyHistogram")
{
    propertynames = nullptr;
}

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

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

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

const char *cDoubleHistogramDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cDoubleHistogramDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cDoubleHistogram *pp = (cDoubleHistogram *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cKSplitDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cKSplitDescriptor();
    virtual ~cKSplitDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cKSplitDescriptor)

cKSplitDescriptor::cKSplitDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cKSplit)), "omnetpp::cPrecollectionBasedDensityEst")
{
    propertynames = nullptr;
}

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

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

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

const char *cKSplitDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cKSplitDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cKSplit *pp = (cKSplit *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cPSquareDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cPSquareDescriptor();
    virtual ~cPSquareDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPSquareDescriptor)

cPSquareDescriptor::cPSquareDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPSquare)), "omnetpp::cAbstractHistogram")
{
    propertynames = nullptr;
}

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

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

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

const char *cPSquareDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cPSquareDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPSquare *pp = (cPSquare *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cExpressionDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_str,
    };
  public:
    cExpressionDescriptor();
    virtual ~cExpressionDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cExpressionDescriptor)

cExpressionDescriptor::cExpressionDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cExpression)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cExpressionDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cExpressionDescriptor::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 FIELD_str:
            if (!strcmp(propertyname, "getter")) return "str";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cExpressionDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cExpression *pp = (cExpression *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cExpressionDescriptor::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();
    }
    cExpression *pp = (cExpression *)object; (void)pp;
    switch (field) {
        case FIELD_str: return oppstring2string(pp->str());
        default: return "";
    }
}

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

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

class cFSMDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_state,
        FIELD_stateName,
    };
  public:
    cFSMDescriptor();
    virtual ~cFSMDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cFSMDescriptor)

cFSMDescriptor::cFSMDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cFSM)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cFSMDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

const char *cFSMDescriptor::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[] = {
        "int",    // FIELD_state
        "string",    // FIELD_stateName
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cFSMDescriptor::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 FIELD_state:
            if (!strcmp(propertyname, "hint")) return "Numeric code of the state the FSM is currently in";
            return nullptr;
        case FIELD_stateName:
            if (!strcmp(propertyname, "hint")) return "Name of the current FSM state";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cFSMDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cFSM *pp = (cFSM *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cFSMDescriptor::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();
    }
    cFSM *pp = (cFSM *)object; (void)pp;
    switch (field) {
        case FIELD_state: return long2string(pp->getState());
        case FIELD_stateName: return oppstring2string(pp->getStateName());
        default: return "";
    }
}

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

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

class cNedMathFunctionDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_category,
        FIELD_description,
        FIELD_numArgs,
    };
  public:
    cNedMathFunctionDescriptor();
    virtual ~cNedMathFunctionDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cNedMathFunctionDescriptor)

cNedMathFunctionDescriptor::cNedMathFunctionDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cNedMathFunction)), "omnetpp::cNoncopyableOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cNedMathFunctionDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cNedMathFunctionDescriptor::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[] = {
        0,    // FIELD_category
        0,    // FIELD_description
        0,    // FIELD_numArgs
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cNedMathFunctionDescriptor::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[] = {
        "category",
        "description",
        "numArgs",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cNedMathFunctionDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "category") == 0) return base+0;
    if (fieldName[0] == 'd' && strcmp(fieldName, "description") == 0) return base+1;
    if (fieldName[0] == 'n' && strcmp(fieldName, "numArgs") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cNedMathFunctionDescriptor::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",    // FIELD_category
        "string",    // FIELD_description
        "int",    // FIELD_numArgs
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

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

const char *cNedMathFunctionDescriptor::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 FIELD_category:
            if (!strcmp(propertyname, "hint")) return "Function category";
            return nullptr;
        case FIELD_numArgs:
            if (!strcmp(propertyname, "hint")) return "Number of \"double\" parameters this function takes";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cNedMathFunctionDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cNedMathFunction *pp = (cNedMathFunction *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cNedMathFunctionDescriptor::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();
    }
    cNedMathFunction *pp = (cNedMathFunction *)object; (void)pp;
    switch (field) {
        case FIELD_category: return oppstring2string(pp->getCategory());
        case FIELD_description: return oppstring2string(pp->getDescription());
        case FIELD_numArgs: return long2string(pp->getNumArgs());
        default: return "";
    }
}

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

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

class cNedFunctionDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_signature,
        FIELD_category,
        FIELD_description,
        FIELD_returnType,
        FIELD_argType,
        FIELD_minArgs,
        FIELD_maxArgs,
    };
  public:
    cNedFunctionDescriptor();
    virtual ~cNedFunctionDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cNedFunctionDescriptor)

cNedFunctionDescriptor::cNedFunctionDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cNedFunction)), "omnetpp::cNoncopyableOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cNedFunctionDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cNedFunctionDescriptor::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[] = {
        0,    // FIELD_signature
        0,    // FIELD_category
        0,    // FIELD_description
        0,    // FIELD_returnType
        FD_ISARRAY,    // FIELD_argType
        0,    // FIELD_minArgs
        0,    // FIELD_maxArgs
    };
    return (field >= 0 && field < 7) ? fieldTypeFlags[field] : 0;
}

const char *cNedFunctionDescriptor::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[] = {
        "signature",
        "category",
        "description",
        "returnType",
        "argType",
        "minArgs",
        "maxArgs",
    };
    return (field >= 0 && field < 7) ? fieldNames[field] : nullptr;
}

int cNedFunctionDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 's' && strcmp(fieldName, "signature") == 0) return base+0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "category") == 0) return base+1;
    if (fieldName[0] == 'd' && strcmp(fieldName, "description") == 0) return base+2;
    if (fieldName[0] == 'r' && strcmp(fieldName, "returnType") == 0) return base+3;
    if (fieldName[0] == 'a' && strcmp(fieldName, "argType") == 0) return base+4;
    if (fieldName[0] == 'm' && strcmp(fieldName, "minArgs") == 0) return base+5;
    if (fieldName[0] == 'm' && strcmp(fieldName, "maxArgs") == 0) return base+6;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cNedFunctionDescriptor::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",    // FIELD_signature
        "string",    // FIELD_category
        "string",    // FIELD_description
        "char",    // FIELD_returnType
        "char",    // FIELD_argType
        "int",    // FIELD_minArgs
        "int",    // FIELD_maxArgs
    };
    return (field >= 0 && field < 7) ? fieldTypeStrings[field] : nullptr;
}

const char **cNedFunctionDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_signature: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_category: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_argType: {
            static const char *names[] = { "sizeGetter",  nullptr };
            return names;
        }
        case FIELD_minArgs: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_maxArgs: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cNedFunctionDescriptor::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 FIELD_signature:
            if (!strcmp(propertyname, "hint")) return "Argument types and return value";
            return nullptr;
        case FIELD_category:
            if (!strcmp(propertyname, "hint")) return "Function category";
            return nullptr;
        case FIELD_argType:
            if (!strcmp(propertyname, "sizeGetter")) return "getMaxArgs";
            return nullptr;
        case FIELD_minArgs:
            if (!strcmp(propertyname, "hint")) return "Number of mandatory arguments";
            return nullptr;
        case FIELD_maxArgs:
            if (!strcmp(propertyname, "hint")) return "Maximum number of arguments";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cNedFunctionDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cNedFunction *pp = (cNedFunction *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cNedFunctionDescriptor::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();
    }
    cNedFunction *pp = (cNedFunction *)object; (void)pp;
    switch (field) {
        case FIELD_signature: return oppstring2string(pp->getSignature());
        case FIELD_category: return oppstring2string(pp->getCategory());
        case FIELD_description: return oppstring2string(pp->getDescription());
        case FIELD_returnType: return long2string(pp->getReturnType());
        case FIELD_argType: return long2string(pp->getArgType(i));
        case FIELD_minArgs: return long2string(pp->getMinArgs());
        case FIELD_maxArgs: return long2string(pp->getMaxArgs());
        default: return "";
    }
}

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

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

class cOutVectorDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_isEnabled,
        FIELD_valuesReceived,
        FIELD_valuesStored,
    };
  public:
    cOutVectorDescriptor();
    virtual ~cOutVectorDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cOutVectorDescriptor)

cOutVectorDescriptor::cOutVectorDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cOutVector)), "omnetpp::cNoncopyableOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cOutVectorDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "outvector";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

const char *cOutVectorDescriptor::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[] = {
        "isEnabled",
        "valuesReceived",
        "valuesStored",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cOutVectorDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isEnabled") == 0) return base+0;
    if (fieldName[0] == 'v' && strcmp(fieldName, "valuesReceived") == 0) return base+1;
    if (fieldName[0] == 'v' && strcmp(fieldName, "valuesStored") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cOutVectorDescriptor::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[] = {
        "bool",    // FIELD_isEnabled
        "long",    // FIELD_valuesReceived
        "long",    // FIELD_valuesStored
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cOutVectorDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_isEnabled: {
            static const char *names[] = { "getter", "setter", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_valuesReceived: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_valuesStored: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cOutVectorDescriptor::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 FIELD_isEnabled:
            if (!strcmp(propertyname, "getter")) return "isEnabled";
            if (!strcmp(propertyname, "setter")) return "setEnabled";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "If disabled, values passed to this object to record are simply discarded";
            return nullptr;
        case FIELD_valuesReceived:
            if (!strcmp(propertyname, "hint")) return "Number of values passed to this object to record";
            return nullptr;
        case FIELD_valuesStored:
            if (!strcmp(propertyname, "hint")) return "Number of values actually stored on the disk";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cOutVectorDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cOutVector *pp = (cOutVector *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cOutVectorDescriptor::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();
    }
    cOutVector *pp = (cOutVector *)object; (void)pp;
    switch (field) {
        case FIELD_isEnabled: return bool2string(pp->isEnabled());
        case FIELD_valuesReceived: return long2string(pp->getValuesReceived());
        case FIELD_valuesStored: return long2string(pp->getValuesStored());
        default: return "";
    }
}

bool cOutVectorDescriptor::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();
    }
    cOutVector *pp = (cOutVector *)object; (void)pp;
    switch (field) {
        case FIELD_isEnabled: pp->setEnabled(string2bool(value)); return true;
        default: return false;
    }
}

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

class cParDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_value,
        FIELD_type,
        FIELD_unit,
        FIELD_isNumeric,
        FIELD_isVolatile,
        FIELD_isExpression,
        FIELD_isShared,
    };
  public:
    cParDescriptor();
    virtual ~cParDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cParDescriptor)

cParDescriptor::cParDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPar)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cParDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "param";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cParDescriptor::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,    // FIELD_value
        0,    // FIELD_type
        0,    // FIELD_unit
        0,    // FIELD_isNumeric
        0,    // FIELD_isVolatile
        0,    // FIELD_isExpression
        0,    // FIELD_isShared
    };
    return (field >= 0 && field < 7) ? fieldTypeFlags[field] : 0;
}

const char *cParDescriptor::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[] = {
        "value",
        "type",
        "unit",
        "isNumeric",
        "isVolatile",
        "isExpression",
        "isShared",
    };
    return (field >= 0 && field < 7) ? fieldNames[field] : nullptr;
}

int cParDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'v' && strcmp(fieldName, "value") == 0) return base+0;
    if (fieldName[0] == 't' && strcmp(fieldName, "type") == 0) return base+1;
    if (fieldName[0] == 'u' && strcmp(fieldName, "unit") == 0) return base+2;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isNumeric") == 0) return base+3;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isVolatile") == 0) return base+4;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isExpression") == 0) return base+5;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isShared") == 0) return base+6;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cParDescriptor::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",    // FIELD_value
        "char",    // FIELD_type
        "string",    // FIELD_unit
        "bool",    // FIELD_isNumeric
        "bool",    // FIELD_isVolatile
        "bool",    // FIELD_isExpression
        "bool",    // FIELD_isShared
    };
    return (field >= 0 && field < 7) ? fieldTypeStrings[field] : nullptr;
}

const char **cParDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_value: {
            static const char *names[] = { "getter", "setter", "editable",  nullptr };
            return names;
        }
        case FIELD_type: {
            static const char *names[] = { "enum", "hint", "enum",  nullptr };
            return names;
        }
        case FIELD_unit: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_isNumeric: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isVolatile: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isExpression: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isShared: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cParDescriptor::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 FIELD_value:
            if (!strcmp(propertyname, "getter")) return "str";
            if (!strcmp(propertyname, "setter")) return "parse";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_type:
            if (!strcmp(propertyname, "enum")) return "cPar::Type";
            if (!strcmp(propertyname, "hint")) return "Parameter type";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cPar::Type";
            return nullptr;
        case FIELD_unit:
            if (!strcmp(propertyname, "hint")) return "For long and double types only";
            return nullptr;
        case FIELD_isNumeric:
            if (!strcmp(propertyname, "getter")) return "isNumeric";
            if (!strcmp(propertyname, "group")) return "flags";
            if (!strcmp(propertyname, "hint")) return "Whether parameter type is numeric, i.e. double or long";
            return nullptr;
        case FIELD_isVolatile:
            if (!strcmp(propertyname, "getter")) return "isVolatile";
            if (!strcmp(propertyname, "group")) return "flags";
            if (!strcmp(propertyname, "hint")) return "Whether parameter was declared volatile in the NED file";
            return nullptr;
        case FIELD_isExpression:
            if (!strcmp(propertyname, "getter")) return "isExpression";
            if (!strcmp(propertyname, "group")) return "flags";
            if (!strcmp(propertyname, "hint")) return "Whether parameter value is a constant or an expression";
            return nullptr;
        case FIELD_isShared:
            if (!strcmp(propertyname, "getter")) return "isShared";
            if (!strcmp(propertyname, "group")) return "flags";
            if (!strcmp(propertyname, "hint")) return "Whether storage could be optimized by several modules sharing the same parameter value object";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cParDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPar *pp = (cPar *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cParDescriptor::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();
    }
    cPar *pp = (cPar *)object; (void)pp;
    switch (field) {
        case FIELD_value: return oppstring2string(pp->str());
        case FIELD_type: return enum2string(pp->getType(), "omnetpp::cPar::Type");
        case FIELD_unit: return oppstring2string(pp->getUnit());
        case FIELD_isNumeric: return bool2string(pp->isNumeric());
        case FIELD_isVolatile: return bool2string(pp->isVolatile());
        case FIELD_isExpression: return bool2string(pp->isExpression());
        case FIELD_isShared: return bool2string(pp->isShared());
        default: return "";
    }
}

bool cParDescriptor::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();
    }
    cPar *pp = (cPar *)object; (void)pp;
    switch (field) {
        case FIELD_value: pp->parse((value)); return true;
        default: return false;
    }
}

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

class cMsgParDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_value,
        FIELD_type,
        FIELD_isNumeric,
        FIELD_isConstant,
    };
  public:
    cMsgParDescriptor();
    virtual ~cMsgParDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cMsgParDescriptor)

cMsgParDescriptor::cMsgParDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cMsgPar)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cMsgParDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cMsgParDescriptor::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,    // FIELD_value
        0,    // FIELD_type
        0,    // FIELD_isNumeric
        0,    // FIELD_isConstant
    };
    return (field >= 0 && field < 4) ? fieldTypeFlags[field] : 0;
}

const char *cMsgParDescriptor::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[] = {
        "value",
        "type",
        "isNumeric",
        "isConstant",
    };
    return (field >= 0 && field < 4) ? fieldNames[field] : nullptr;
}

int cMsgParDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'v' && strcmp(fieldName, "value") == 0) return base+0;
    if (fieldName[0] == 't' && strcmp(fieldName, "type") == 0) return base+1;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isNumeric") == 0) return base+2;
    if (fieldName[0] == 'i' && strcmp(fieldName, "isConstant") == 0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cMsgParDescriptor::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",    // FIELD_value
        "char",    // FIELD_type
        "bool",    // FIELD_isNumeric
        "bool",    // FIELD_isConstant
    };
    return (field >= 0 && field < 4) ? fieldTypeStrings[field] : nullptr;
}

const char **cMsgParDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_value: {
            static const char *names[] = { "getter", "setter", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_type: {
            static const char *names[] = { "enum", "hint", "enum",  nullptr };
            return names;
        }
        case FIELD_isNumeric: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        case FIELD_isConstant: {
            static const char *names[] = { "getter", "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cMsgParDescriptor::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 FIELD_value:
            if (!strcmp(propertyname, "getter")) return "str";
            if (!strcmp(propertyname, "setter")) return "parse";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "Parameter value";
            return nullptr;
        case FIELD_type:
            if (!strcmp(propertyname, "enum")) return "cPar::Type";
            if (!strcmp(propertyname, "hint")) return "Parameter type";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cPar::Type";
            return nullptr;
        case FIELD_isNumeric:
            if (!strcmp(propertyname, "getter")) return "isNumeric";
            if (!strcmp(propertyname, "group")) return "flags";
            if (!strcmp(propertyname, "hint")) return "Whether parameter is of numeric type";
            return nullptr;
        case FIELD_isConstant:
            if (!strcmp(propertyname, "getter")) return "isConstant";
            if (!strcmp(propertyname, "group")) return "flags";
            if (!strcmp(propertyname, "hint")) return "Whether the parameter has a constant value";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cMsgParDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cMsgPar *pp = (cMsgPar *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cMsgParDescriptor::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();
    }
    cMsgPar *pp = (cMsgPar *)object; (void)pp;
    switch (field) {
        case FIELD_value: return oppstring2string(pp->str());
        case FIELD_type: return enum2string(pp->getType(), "omnetpp::cPar::Type");
        case FIELD_isNumeric: return bool2string(pp->isNumeric());
        case FIELD_isConstant: return bool2string(pp->isConstant());
        default: return "";
    }
}

bool cMsgParDescriptor::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();
    }
    cMsgPar *pp = (cMsgPar *)object; (void)pp;
    switch (field) {
        case FIELD_value: pp->parse((value)); return true;
        default: return false;
    }
}

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

class cFutureEventSetDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_length,
        FIELD_events,
    };
  public:
    cFutureEventSetDescriptor();
    virtual ~cFutureEventSetDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cFutureEventSetDescriptor)

cFutureEventSetDescriptor::cFutureEventSetDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cFutureEventSet)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cFutureEventSetDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "container";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cFutureEventSetDescriptor::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[] = {
        0,    // FIELD_length
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_events
    };
    return (field >= 0 && field < 2) ? fieldTypeFlags[field] : 0;
}

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

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

const char *cFutureEventSetDescriptor::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[] = {
        "int",    // FIELD_length
        "omnetpp::cEvent",    // FIELD_events
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **cFutureEventSetDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_length: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_events: {
            static const char *names[] = { "getter", "sizeGetter", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cFutureEventSetDescriptor::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 FIELD_length:
            if (!strcmp(propertyname, "hint")) return "Number of items contained";
            return nullptr;
        case FIELD_events:
            if (!strcmp(propertyname, "getter")) return "get";
            if (!strcmp(propertyname, "sizeGetter")) return "getLength";
            if (!strcmp(propertyname, "hint")) return "Events and self-messages and currently scheduled, and messages currently in transit";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cFutureEventSetDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cFutureEventSet *pp = (cFutureEventSet *)object; (void)pp;
    switch (field) {
        case FIELD_events: { const cEvent * value = pp->get(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cFutureEventSetDescriptor::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();
    }
    cFutureEventSet *pp = (cFutureEventSet *)object; (void)pp;
    switch (field) {
        case FIELD_length: return long2string(pp->getLength());
        case FIELD_events: {std::stringstream out; out << pp->get(i); return out.str();}
        default: return "";
    }
}

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

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

void *cFutureEventSetDescriptor::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();
    }
    cFutureEventSet *pp = (cFutureEventSet *)object; (void)pp;
    switch (field) {
        case FIELD_events: return toVoidPtr(pp->get(i)); break;
        default: return nullptr;
    }
}

class cEventHeapDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cEventHeapDescriptor();
    virtual ~cEventHeapDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cEventHeapDescriptor)

cEventHeapDescriptor::cEventHeapDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cEventHeap)), "omnetpp::cFutureEventSet")
{
    propertynames = nullptr;
}

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

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

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

const char *cEventHeapDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cEventHeapDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cEventHeap *pp = (cEventHeap *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cQueueDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_takeOwnership,
        FIELD_length,
        FIELD_contents,
    };
  public:
    cQueueDescriptor();
    virtual ~cQueueDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cQueueDescriptor)

cQueueDescriptor::cQueueDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cQueue)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cQueueDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "queue";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cQueueDescriptor::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,    // FIELD_takeOwnership
        0,    // FIELD_length
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_contents
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cQueueDescriptor::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[] = {
        "takeOwnership",
        "length",
        "contents",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cQueueDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 't' && strcmp(fieldName, "takeOwnership") == 0) return base+0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "length") == 0) return base+1;
    if (fieldName[0] == 'c' && strcmp(fieldName, "contents") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cQueueDescriptor::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[] = {
        "bool",    // FIELD_takeOwnership
        "int",    // FIELD_length
        "omnetpp::cObject",    // FIELD_contents
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cQueueDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_takeOwnership: {
            static const char *names[] = { "group", "editable", "hint",  nullptr };
            return names;
        }
        case FIELD_length: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_contents: {
            static const char *names[] = { "getter", "sizeGetter", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cQueueDescriptor::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 FIELD_takeOwnership:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "hint")) return "Whether the queue should own the objects inserted into it";
            return nullptr;
        case FIELD_length:
            if (!strcmp(propertyname, "hint")) return "Number of items in the queue";
            return nullptr;
        case FIELD_contents:
            if (!strcmp(propertyname, "getter")) return "get";
            if (!strcmp(propertyname, "sizeGetter")) return "getLength";
            if (!strcmp(propertyname, "hint")) return "Queue contents";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cQueueDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cQueue *pp = (cQueue *)object; (void)pp;
    switch (field) {
        case FIELD_contents: { const cObject * value = pp->get(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cQueueDescriptor::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();
    }
    cQueue *pp = (cQueue *)object; (void)pp;
    switch (field) {
        case FIELD_takeOwnership: return bool2string(pp->getTakeOwnership());
        case FIELD_length: return long2string(pp->getLength());
        case FIELD_contents: {std::stringstream out; out << pp->get(i); return out.str();}
        default: return "";
    }
}

bool cQueueDescriptor::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();
    }
    cQueue *pp = (cQueue *)object; (void)pp;
    switch (field) {
        case FIELD_takeOwnership: pp->setTakeOwnership(string2bool(value)); return true;
        default: return false;
    }
}

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

void *cQueueDescriptor::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();
    }
    cQueue *pp = (cQueue *)object; (void)pp;
    switch (field) {
        case FIELD_contents: return toVoidPtr(pp->get(i)); break;
        default: return nullptr;
    }
}

class cPacketQueueDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_bitLength,
        FIELD_byteLength,
    };
  public:
    cPacketQueueDescriptor();
    virtual ~cPacketQueueDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPacketQueueDescriptor)

cPacketQueueDescriptor::cPacketQueueDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPacketQueue)), "omnetpp::cQueue")
{
    propertynames = nullptr;
}

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

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

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

const char *cPacketQueueDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cPacketQueueDescriptor::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 FIELD_bitLength:
            if (!strcmp(propertyname, "hint")) return "Total size of messages in the queue";
            return nullptr;
        case FIELD_byteLength:
            if (!strcmp(propertyname, "hint")) return "Total size of messages in the queue, in bytes";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cPacketQueueDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPacketQueue *pp = (cPacketQueue *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPacketQueueDescriptor::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();
    }
    cPacketQueue *pp = (cPacketQueue *)object; (void)pp;
    switch (field) {
        case FIELD_bitLength: return int642string(pp->getBitLength());
        case FIELD_byteLength: return int642string(pp->getByteLength());
        default: return "";
    }
}

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

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

class cHasherDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_hash,
    };
  public:
    cHasherDescriptor();
    virtual ~cHasherDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cHasherDescriptor)

cHasherDescriptor::cHasherDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cHasher)), "")
{
    propertynames = nullptr;
}

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

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

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

const char *cHasherDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cHasherDescriptor::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 FIELD_hash:
            if (!strcmp(propertyname, "getter")) return "str";
            if (!strcmp(propertyname, "hint")) return "The current hash value";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cHasherDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cHasher *pp = (cHasher *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cHasherDescriptor::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();
    }
    cHasher *pp = (cHasher *)object; (void)pp;
    switch (field) {
        case FIELD_hash: return oppstring2string(pp->str());
        default: return "";
    }
}

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

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

class cFingerprintCalculatorDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cFingerprintCalculatorDescriptor();
    virtual ~cFingerprintCalculatorDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cFingerprintCalculatorDescriptor)

cFingerprintCalculatorDescriptor::cFingerprintCalculatorDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cFingerprintCalculator)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cFingerprintCalculatorDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cFingerprintCalculatorDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cFingerprintCalculator *pp = (cFingerprintCalculator *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cSimulationDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_simTime,
        FIELD_eventNumber,
        FIELD_fes,
        FIELD_lastComponentId,
        FIELD_systemModule,
        FIELD_component,
        FIELD_fingerprintCalculator,
    };
  public:
    cSimulationDescriptor();
    virtual ~cSimulationDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cSimulationDescriptor)

cSimulationDescriptor::cSimulationDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cSimulation)), "omnetpp::cNoncopyableOwnedObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cSimulationDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    if (!strcmp(propertyname, "icon")) return "container";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cSimulationDescriptor::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[] = {
        0,    // FIELD_simTime
        0,    // FIELD_eventNumber
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_fes
        0,    // FIELD_lastComponentId
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_systemModule
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_component
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_fingerprintCalculator
    };
    return (field >= 0 && field < 7) ? fieldTypeFlags[field] : 0;
}

const char *cSimulationDescriptor::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[] = {
        "simTime",
        "eventNumber",
        "fes",
        "lastComponentId",
        "systemModule",
        "component",
        "fingerprintCalculator",
    };
    return (field >= 0 && field < 7) ? fieldNames[field] : nullptr;
}

int cSimulationDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 's' && strcmp(fieldName, "simTime") == 0) return base+0;
    if (fieldName[0] == 'e' && strcmp(fieldName, "eventNumber") == 0) return base+1;
    if (fieldName[0] == 'f' && strcmp(fieldName, "fes") == 0) return base+2;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastComponentId") == 0) return base+3;
    if (fieldName[0] == 's' && strcmp(fieldName, "systemModule") == 0) return base+4;
    if (fieldName[0] == 'c' && strcmp(fieldName, "component") == 0) return base+5;
    if (fieldName[0] == 'f' && strcmp(fieldName, "fingerprintCalculator") == 0) return base+6;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cSimulationDescriptor::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[] = {
        "omnetpp::simtime_t",    // FIELD_simTime
        "int64_t",    // FIELD_eventNumber
        "omnetpp::cFutureEventSet",    // FIELD_fes
        "int",    // FIELD_lastComponentId
        "omnetpp::cModule",    // FIELD_systemModule
        "omnetpp::cComponent",    // FIELD_component
        "omnetpp::cFingerprintCalculator",    // FIELD_fingerprintCalculator
    };
    return (field >= 0 && field < 7) ? fieldTypeStrings[field] : nullptr;
}

const char **cSimulationDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_simTime: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_eventNumber: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_fes: {
            static const char *names[] = { "getter", "label", "hint",  nullptr };
            return names;
        }
        case FIELD_lastComponentId: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_systemModule: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_component: {
            static const char *names[] = { "sizeGetter", "group", "label", "hint",  nullptr };
            return names;
        }
        case FIELD_fingerprintCalculator: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cSimulationDescriptor::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 FIELD_simTime:
            if (!strcmp(propertyname, "hint")) return "The current simulation time in seconds";
            return nullptr;
        case FIELD_eventNumber:
            if (!strcmp(propertyname, "hint")) return "The current event number -- counts from 0 up";
            return nullptr;
        case FIELD_fes:
            if (!strcmp(propertyname, "getter")) return "getFES";
            if (!strcmp(propertyname, "label")) return "futureEvents";
            if (!strcmp(propertyname, "hint")) return "Self-messages scheduled, and messages in transit";
            return nullptr;
        case FIELD_lastComponentId:
            if (!strcmp(propertyname, "group")) return "components";
            if (!strcmp(propertyname, "hint")) return "The largest component ID issued so far";
            return nullptr;
        case FIELD_systemModule:
            if (!strcmp(propertyname, "group")) return "components";
            if (!strcmp(propertyname, "hint")) return "The top-level module";
            return nullptr;
        case FIELD_component:
            if (!strcmp(propertyname, "sizeGetter")) return "getLastComponentId";
            if (!strcmp(propertyname, "group")) return "components";
            if (!strcmp(propertyname, "label")) return "components";
            if (!strcmp(propertyname, "hint")) return "List of components indexed by component ID";
            return nullptr;
        case FIELD_fingerprintCalculator:
            if (!strcmp(propertyname, "hint")) return "Used for computing simulation fingerprint";
            return nullptr;
        default: return nullptr;
    }
}

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

const char *cSimulationDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cSimulation *pp = (cSimulation *)object; (void)pp;
    switch (field) {
        case FIELD_fes: { const cFutureEventSet * value = pp->getFES(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_systemModule: { const cModule * value = pp->getSystemModule(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_component: { const cComponent * value = pp->getComponent(i); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_fingerprintCalculator: { const cFingerprintCalculator * value = pp->getFingerprintCalculator(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cSimulationDescriptor::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();
    }
    cSimulation *pp = (cSimulation *)object; (void)pp;
    switch (field) {
        case FIELD_simTime: return simtime2string(pp->getSimTime());
        case FIELD_eventNumber: return int642string(pp->getEventNumber());
        case FIELD_fes: {std::stringstream out; out << pp->getFES(); return out.str();}
        case FIELD_lastComponentId: return long2string(pp->getLastComponentId());
        case FIELD_systemModule: {std::stringstream out; out << pp->getSystemModule(); return out.str();}
        case FIELD_component: {std::stringstream out; out << pp->getComponent(i); return out.str();}
        case FIELD_fingerprintCalculator: {std::stringstream out; out << pp->getFingerprintCalculator(); return out.str();}
        default: return "";
    }
}

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

const char *cSimulationDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_fes: return omnetpp::opp_typename(typeid(cFutureEventSet));
        case FIELD_systemModule: return omnetpp::opp_typename(typeid(cModule));
        case FIELD_component: return omnetpp::opp_typename(typeid(cComponent));
        case FIELD_fingerprintCalculator: return omnetpp::opp_typename(typeid(cFingerprintCalculator));
        default: return nullptr;
    };
}

void *cSimulationDescriptor::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();
    }
    cSimulation *pp = (cSimulation *)object; (void)pp;
    switch (field) {
        case FIELD_fes: return toVoidPtr(pp->getFES()); break;
        case FIELD_systemModule: return toVoidPtr(pp->getSystemModule()); break;
        case FIELD_component: return toVoidPtr(pp->getComponent(i)); break;
        case FIELD_fingerprintCalculator: return toVoidPtr(pp->getFingerprintCalculator()); break;
        default: return nullptr;
    }
}

class cSchedulerDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cSchedulerDescriptor();
    virtual ~cSchedulerDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cSchedulerDescriptor)

cSchedulerDescriptor::cSchedulerDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cScheduler)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

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

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

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

const char *cSchedulerDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cSchedulerDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cScheduler *pp = (cScheduler *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cSequentialSchedulerDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cSequentialSchedulerDescriptor();
    virtual ~cSequentialSchedulerDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cSequentialSchedulerDescriptor)

cSequentialSchedulerDescriptor::cSequentialSchedulerDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cSequentialScheduler)), "omnetpp::cScheduler")
{
    propertynames = nullptr;
}

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

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

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

const char *cSequentialSchedulerDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

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

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

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

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

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

const char *cSequentialSchedulerDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cSequentialScheduler *pp = (cSequentialScheduler *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

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

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

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

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

class cRealTimeSchedulerDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cRealTimeSchedulerDescriptor();
    virtual ~cRealTimeSchedulerDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cRealTimeSchedulerDescriptor)

cRealTimeSchedulerDescriptor::cRealTimeSchedulerDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cRealTimeScheduler)), "omnetpp::cScheduler")
{
    propertynames = nullptr;
}

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

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

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

const char *cRealTimeSchedulerDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

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

unsigned int cRealTimeSchedulerDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cRealTimeSchedulerDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cRealTimeSchedulerDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cRealTimeSchedulerDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cRealTimeSchedulerDescriptor::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 *cRealTimeSchedulerDescriptor::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 cRealTimeSchedulerDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cRealTimeScheduler *pp = (cRealTimeScheduler *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cRealTimeSchedulerDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cRealTimeScheduler *pp = (cRealTimeScheduler *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cRealTimeSchedulerDescriptor::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();
    }
    cRealTimeScheduler *pp = (cRealTimeScheduler *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cRealTimeSchedulerDescriptor::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();
    }
    cRealTimeScheduler *pp = (cRealTimeScheduler *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cRealTimeSchedulerDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cRealTimeSchedulerDescriptor::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();
    }
    cRealTimeScheduler *pp = (cRealTimeScheduler *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cTopology__NodeDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_moduleId,
        FIELD_module,
        FIELD_weight,
        FIELD_enabled,
        FIELD_inLink,
        FIELD_outLink,
        FIELD_distanceToTarget,
        FIELD_path,
    };
  public:
    cTopology__NodeDescriptor();
    virtual ~cTopology__NodeDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cTopology__NodeDescriptor)

cTopology__NodeDescriptor::cTopology__NodeDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cTopology::Node)), "")
{
    propertynames = nullptr;
}

cTopology__NodeDescriptor::~cTopology__NodeDescriptor()
{
    delete[] propertynames;
}

bool cTopology__NodeDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cTopology::Node *>(obj)!=nullptr;
}

const char **cTopology__NodeDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cTopology__NodeDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cTopology__NodeDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 8+basedesc->getFieldCount() : 8;
}

unsigned int cTopology__NodeDescriptor::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[] = {
        0,    // FIELD_moduleId
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_module
        0,    // FIELD_weight
        0,    // FIELD_enabled
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER,    // FIELD_inLink
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER,    // FIELD_outLink
        0,    // FIELD_distanceToTarget
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER,    // FIELD_path
    };
    return (field >= 0 && field < 8) ? fieldTypeFlags[field] : 0;
}

const char *cTopology__NodeDescriptor::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[] = {
        "moduleId",
        "module",
        "weight",
        "enabled",
        "inLink",
        "outLink",
        "distanceToTarget",
        "path",
    };
    return (field >= 0 && field < 8) ? fieldNames[field] : nullptr;
}

int cTopology__NodeDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'm' && strcmp(fieldName, "moduleId") == 0) return base+0;
    if (fieldName[0] == 'm' && strcmp(fieldName, "module") == 0) return base+1;
    if (fieldName[0] == 'w' && strcmp(fieldName, "weight") == 0) return base+2;
    if (fieldName[0] == 'e' && strcmp(fieldName, "enabled") == 0) return base+3;
    if (fieldName[0] == 'i' && strcmp(fieldName, "inLink") == 0) return base+4;
    if (fieldName[0] == 'o' && strcmp(fieldName, "outLink") == 0) return base+5;
    if (fieldName[0] == 'd' && strcmp(fieldName, "distanceToTarget") == 0) return base+6;
    if (fieldName[0] == 'p' && strcmp(fieldName, "path") == 0) return base+7;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cTopology__NodeDescriptor::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[] = {
        "int",    // FIELD_moduleId
        "omnetpp::cModule",    // FIELD_module
        "double",    // FIELD_weight
        "bool",    // FIELD_enabled
        "omnetpp::cTopology::LinkIn",    // FIELD_inLink
        "omnetpp::cTopology::LinkOut",    // FIELD_outLink
        "double",    // FIELD_distanceToTarget
        "omnetpp::cTopology::LinkOut",    // FIELD_path
    };
    return (field >= 0 && field < 8) ? fieldTypeStrings[field] : nullptr;
}

const char **cTopology__NodeDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_moduleId: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_module: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_weight: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_enabled: {
            static const char *names[] = { "getter", "hint",  nullptr };
            return names;
        }
        case FIELD_inLink: {
            static const char *names[] = { "getter", "sizeGetter", "hint",  nullptr };
            return names;
        }
        case FIELD_outLink: {
            static const char *names[] = { "getter", "sizeGetter", "hint",  nullptr };
            return names;
        }
        case FIELD_distanceToTarget: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_path: {
            static const char *names[] = { "sizeGetter", "group", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cTopology__NodeDescriptor::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 FIELD_moduleId:
            if (!strcmp(propertyname, "hint")) return "ID of the module this node corresponds to";
            return nullptr;
        case FIELD_module:
            if (!strcmp(propertyname, "hint")) return "The module this node corresponds to";
            return nullptr;
        case FIELD_weight:
            if (!strcmp(propertyname, "hint")) return "Node weight -- affects graph algorithms such as shortest path";
            return nullptr;
        case FIELD_enabled:
            if (!strcmp(propertyname, "getter")) return "isEnabled";
            if (!strcmp(propertyname, "hint")) return "Node state -- affects graph algorithms such as shortest path";
            return nullptr;
        case FIELD_inLink:
            if (!strcmp(propertyname, "getter")) return "getLinkIn";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumInLinks";
            if (!strcmp(propertyname, "hint")) return "Incoming links of this graph node";
            return nullptr;
        case FIELD_outLink:
            if (!strcmp(propertyname, "getter")) return "getLinkOut";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumOutLinks";
            if (!strcmp(propertyname, "hint")) return "Outgoing links of this graph node";
            return nullptr;
        case FIELD_distanceToTarget:
            if (!strcmp(propertyname, "group")) return "shortest path";
            if (!strcmp(propertyname, "hint")) return "After running a shortest path algorithm: distance to the target node";
            return nullptr;
        case FIELD_path:
            if (!strcmp(propertyname, "sizeGetter")) return "getNumPaths";
            if (!strcmp(propertyname, "group")) return "shortest path";
            if (!strcmp(propertyname, "hint")) return "The next link of the shortest path or paths towards the target node";
            return nullptr;
        default: return nullptr;
    }
}

int cTopology__NodeDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cTopology::Node *pp = (cTopology::Node *)object; (void)pp;
    switch (field) {
        case FIELD_inLink: return pp->getNumInLinks();
        case FIELD_outLink: return pp->getNumOutLinks();
        case FIELD_path: return pp->getNumPaths();
        default: return 0;
    }
}

const char *cTopology__NodeDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cTopology::Node *pp = (cTopology::Node *)object; (void)pp;
    switch (field) {
        case FIELD_module: { const cModule * value = pp->getModule(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_inLink: { const cTopology::LinkIn * value = pp->getLinkIn(i); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_outLink: { const cTopology::LinkOut * value = pp->getLinkOut(i); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_path: { const cTopology::LinkOut * value = pp->getPath(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cTopology__NodeDescriptor::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();
    }
    cTopology::Node *pp = (cTopology::Node *)object; (void)pp;
    switch (field) {
        case FIELD_moduleId: return long2string(pp->getModuleId());
        case FIELD_module: {std::stringstream out; out << pp->getModule(); return out.str();}
        case FIELD_weight: return double2string(pp->getWeight());
        case FIELD_enabled: return bool2string(pp->isEnabled());
        case FIELD_inLink: {std::stringstream out; out << pp->getLinkIn(i); return out.str();}
        case FIELD_outLink: {std::stringstream out; out << pp->getLinkOut(i); return out.str();}
        case FIELD_distanceToTarget: return double2string(pp->getDistanceToTarget());
        case FIELD_path: {std::stringstream out; out << pp->getPath(i); return out.str();}
        default: return "";
    }
}

bool cTopology__NodeDescriptor::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();
    }
    cTopology::Node *pp = (cTopology::Node *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cTopology__NodeDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_module: return omnetpp::opp_typename(typeid(cModule));
        case FIELD_inLink: return omnetpp::opp_typename(typeid(cTopology::LinkIn));
        case FIELD_outLink: return omnetpp::opp_typename(typeid(cTopology::LinkOut));
        case FIELD_path: return omnetpp::opp_typename(typeid(cTopology::LinkOut));
        default: return nullptr;
    };
}

void *cTopology__NodeDescriptor::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();
    }
    cTopology::Node *pp = (cTopology::Node *)object; (void)pp;
    switch (field) {
        case FIELD_module: return toVoidPtr(pp->getModule()); break;
        case FIELD_inLink: return toVoidPtr(pp->getLinkIn(i)); break;
        case FIELD_outLink: return toVoidPtr(pp->getLinkOut(i)); break;
        case FIELD_path: return toVoidPtr(pp->getPath(i)); break;
        default: return nullptr;
    }
}

class cTopology__LinkDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_weight,
        FIELD_enabled,
    };
  public:
    cTopology__LinkDescriptor();
    virtual ~cTopology__LinkDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cTopology__LinkDescriptor)

cTopology__LinkDescriptor::cTopology__LinkDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cTopology::Link)), "")
{
    propertynames = nullptr;
}

cTopology__LinkDescriptor::~cTopology__LinkDescriptor()
{
    delete[] propertynames;
}

bool cTopology__LinkDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cTopology::Link *>(obj)!=nullptr;
}

const char **cTopology__LinkDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cTopology__LinkDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cTopology__LinkDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 2+basedesc->getFieldCount() : 2;
}

unsigned int cTopology__LinkDescriptor::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[] = {
        0,    // FIELD_weight
        0,    // FIELD_enabled
    };
    return (field >= 0 && field < 2) ? fieldTypeFlags[field] : 0;
}

const char *cTopology__LinkDescriptor::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[] = {
        "weight",
        "enabled",
    };
    return (field >= 0 && field < 2) ? fieldNames[field] : nullptr;
}

int cTopology__LinkDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'w' && strcmp(fieldName, "weight") == 0) return base+0;
    if (fieldName[0] == 'e' && strcmp(fieldName, "enabled") == 0) return base+1;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cTopology__LinkDescriptor::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[] = {
        "double",    // FIELD_weight
        "bool",    // FIELD_enabled
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **cTopology__LinkDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_weight: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_enabled: {
            static const char *names[] = { "getter", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cTopology__LinkDescriptor::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 FIELD_weight:
            if (!strcmp(propertyname, "hint")) return "Link weight -- affects graph algorithms such as shortest path";
            return nullptr;
        case FIELD_enabled:
            if (!strcmp(propertyname, "getter")) return "isEnabled";
            if (!strcmp(propertyname, "hint")) return "Link state -- affects graph algorithms such as shortest path";
            return nullptr;
        default: return nullptr;
    }
}

int cTopology__LinkDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cTopology::Link *pp = (cTopology::Link *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cTopology__LinkDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cTopology::Link *pp = (cTopology::Link *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cTopology__LinkDescriptor::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();
    }
    cTopology::Link *pp = (cTopology::Link *)object; (void)pp;
    switch (field) {
        case FIELD_weight: return double2string(pp->getWeight());
        case FIELD_enabled: return bool2string(pp->isEnabled());
        default: return "";
    }
}

bool cTopology__LinkDescriptor::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();
    }
    cTopology::Link *pp = (cTopology::Link *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cTopology__LinkDescriptor::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 *cTopology__LinkDescriptor::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();
    }
    cTopology::Link *pp = (cTopology::Link *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cTopology__LinkInDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_remoteNode,
        FIELD_remoteGate,
        FIELD_localGate,
    };
  public:
    cTopology__LinkInDescriptor();
    virtual ~cTopology__LinkInDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cTopology__LinkInDescriptor)

cTopology__LinkInDescriptor::cTopology__LinkInDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cTopology::LinkIn)), "omnetpp::cTopology::Link")
{
    propertynames = nullptr;
}

cTopology__LinkInDescriptor::~cTopology__LinkInDescriptor()
{
    delete[] propertynames;
}

bool cTopology__LinkInDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cTopology::LinkIn *>(obj)!=nullptr;
}

const char **cTopology__LinkInDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cTopology__LinkInDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cTopology__LinkInDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int cTopology__LinkInDescriptor::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_ISCOMPOUND | FD_ISPOINTER,    // FIELD_remoteNode
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_remoteGate
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_localGate
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cTopology__LinkInDescriptor::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[] = {
        "remoteNode",
        "remoteGate",
        "localGate",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cTopology__LinkInDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'r' && strcmp(fieldName, "remoteNode") == 0) return base+0;
    if (fieldName[0] == 'r' && strcmp(fieldName, "remoteGate") == 0) return base+1;
    if (fieldName[0] == 'l' && strcmp(fieldName, "localGate") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cTopology__LinkInDescriptor::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[] = {
        "omnetpp::cTopology::Node",    // FIELD_remoteNode
        "omnetpp::cGate",    // FIELD_remoteGate
        "omnetpp::cGate",    // FIELD_localGate
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cTopology__LinkInDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_remoteNode: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_remoteGate: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_localGate: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cTopology__LinkInDescriptor::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 FIELD_remoteNode:
            if (!strcmp(propertyname, "hint")) return "The node at the remote end of this connection";
            return nullptr;
        case FIELD_remoteGate:
            if (!strcmp(propertyname, "hint")) return "The gate at the remote end of this connection";
            return nullptr;
        case FIELD_localGate:
            if (!strcmp(propertyname, "hint")) return "The gate at the local end of this connection";
            return nullptr;
        default: return nullptr;
    }
}

int cTopology__LinkInDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cTopology::LinkIn *pp = (cTopology::LinkIn *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cTopology__LinkInDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cTopology::LinkIn *pp = (cTopology::LinkIn *)object; (void)pp;
    switch (field) {
        case FIELD_remoteNode: { const cTopology::Node * value = pp->getRemoteNode(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_remoteGate: { const cGate * value = pp->getRemoteGate(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_localGate: { const cGate * value = pp->getLocalGate(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cTopology__LinkInDescriptor::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();
    }
    cTopology::LinkIn *pp = (cTopology::LinkIn *)object; (void)pp;
    switch (field) {
        case FIELD_remoteNode: {std::stringstream out; out << pp->getRemoteNode(); return out.str();}
        case FIELD_remoteGate: {std::stringstream out; out << pp->getRemoteGate(); return out.str();}
        case FIELD_localGate: {std::stringstream out; out << pp->getLocalGate(); return out.str();}
        default: return "";
    }
}

bool cTopology__LinkInDescriptor::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();
    }
    cTopology::LinkIn *pp = (cTopology::LinkIn *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cTopology__LinkInDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_remoteNode: return omnetpp::opp_typename(typeid(cTopology::Node));
        case FIELD_remoteGate: return omnetpp::opp_typename(typeid(cGate));
        case FIELD_localGate: return omnetpp::opp_typename(typeid(cGate));
        default: return nullptr;
    };
}

void *cTopology__LinkInDescriptor::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();
    }
    cTopology::LinkIn *pp = (cTopology::LinkIn *)object; (void)pp;
    switch (field) {
        case FIELD_remoteNode: return toVoidPtr(pp->getRemoteNode()); break;
        case FIELD_remoteGate: return toVoidPtr(pp->getRemoteGate()); break;
        case FIELD_localGate: return toVoidPtr(pp->getLocalGate()); break;
        default: return nullptr;
    }
}

class cTopology__LinkOutDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_remoteNode,
        FIELD_remoteGate,
        FIELD_localGate,
    };
  public:
    cTopology__LinkOutDescriptor();
    virtual ~cTopology__LinkOutDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cTopology__LinkOutDescriptor)

cTopology__LinkOutDescriptor::cTopology__LinkOutDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cTopology::LinkOut)), "omnetpp::cTopology::Link")
{
    propertynames = nullptr;
}

cTopology__LinkOutDescriptor::~cTopology__LinkOutDescriptor()
{
    delete[] propertynames;
}

bool cTopology__LinkOutDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cTopology::LinkOut *>(obj)!=nullptr;
}

const char **cTopology__LinkOutDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cTopology__LinkOutDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cTopology__LinkOutDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int cTopology__LinkOutDescriptor::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_ISCOMPOUND | FD_ISPOINTER,    // FIELD_remoteNode
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_remoteGate
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_localGate
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cTopology__LinkOutDescriptor::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[] = {
        "remoteNode",
        "remoteGate",
        "localGate",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cTopology__LinkOutDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'r' && strcmp(fieldName, "remoteNode") == 0) return base+0;
    if (fieldName[0] == 'r' && strcmp(fieldName, "remoteGate") == 0) return base+1;
    if (fieldName[0] == 'l' && strcmp(fieldName, "localGate") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cTopology__LinkOutDescriptor::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[] = {
        "omnetpp::cTopology::Node",    // FIELD_remoteNode
        "omnetpp::cGate",    // FIELD_remoteGate
        "omnetpp::cGate",    // FIELD_localGate
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cTopology__LinkOutDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_remoteNode: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_remoteGate: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_localGate: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cTopology__LinkOutDescriptor::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 FIELD_remoteNode:
            if (!strcmp(propertyname, "hint")) return "The node at the remote end of this connection";
            return nullptr;
        case FIELD_remoteGate:
            if (!strcmp(propertyname, "hint")) return "The gate at the remote end of this connection";
            return nullptr;
        case FIELD_localGate:
            if (!strcmp(propertyname, "hint")) return "The gate at the local end of this connection";
            return nullptr;
        default: return nullptr;
    }
}

int cTopology__LinkOutDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cTopology::LinkOut *pp = (cTopology::LinkOut *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cTopology__LinkOutDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cTopology::LinkOut *pp = (cTopology::LinkOut *)object; (void)pp;
    switch (field) {
        case FIELD_remoteNode: { const cTopology::Node * value = pp->getRemoteNode(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_remoteGate: { const cGate * value = pp->getRemoteGate(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_localGate: { const cGate * value = pp->getLocalGate(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cTopology__LinkOutDescriptor::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();
    }
    cTopology::LinkOut *pp = (cTopology::LinkOut *)object; (void)pp;
    switch (field) {
        case FIELD_remoteNode: {std::stringstream out; out << pp->getRemoteNode(); return out.str();}
        case FIELD_remoteGate: {std::stringstream out; out << pp->getRemoteGate(); return out.str();}
        case FIELD_localGate: {std::stringstream out; out << pp->getLocalGate(); return out.str();}
        default: return "";
    }
}

bool cTopology__LinkOutDescriptor::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();
    }
    cTopology::LinkOut *pp = (cTopology::LinkOut *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cTopology__LinkOutDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_remoteNode: return omnetpp::opp_typename(typeid(cTopology::Node));
        case FIELD_remoteGate: return omnetpp::opp_typename(typeid(cGate));
        case FIELD_localGate: return omnetpp::opp_typename(typeid(cGate));
        default: return nullptr;
    };
}

void *cTopology__LinkOutDescriptor::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();
    }
    cTopology::LinkOut *pp = (cTopology::LinkOut *)object; (void)pp;
    switch (field) {
        case FIELD_remoteNode: return toVoidPtr(pp->getRemoteNode()); break;
        case FIELD_remoteGate: return toVoidPtr(pp->getRemoteGate()); break;
        case FIELD_localGate: return toVoidPtr(pp->getLocalGate()); break;
        default: return nullptr;
    }
}

class cTopologyDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_numNodes,
        FIELD_node,
    };
  public:
    cTopologyDescriptor();
    virtual ~cTopologyDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cTopologyDescriptor)

cTopologyDescriptor::cTopologyDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cTopology)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

cTopologyDescriptor::~cTopologyDescriptor()
{
    delete[] propertynames;
}

bool cTopologyDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cTopology *>(obj)!=nullptr;
}

const char **cTopologyDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cTopologyDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cTopologyDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 2+basedesc->getFieldCount() : 2;
}

unsigned int cTopologyDescriptor::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[] = {
        0,    // FIELD_numNodes
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER,    // FIELD_node
    };
    return (field >= 0 && field < 2) ? fieldTypeFlags[field] : 0;
}

const char *cTopologyDescriptor::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[] = {
        "numNodes",
        "node",
    };
    return (field >= 0 && field < 2) ? fieldNames[field] : nullptr;
}

int cTopologyDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'n' && strcmp(fieldName, "numNodes") == 0) return base+0;
    if (fieldName[0] == 'n' && strcmp(fieldName, "node") == 0) return base+1;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cTopologyDescriptor::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[] = {
        "int",    // FIELD_numNodes
        "omnetpp::cTopology::Node",    // FIELD_node
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **cTopologyDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_numNodes: {
            static const char *names[] = { "group", "hint",  nullptr };
            return names;
        }
        case FIELD_node: {
            static const char *names[] = { "sizeGetter", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cTopologyDescriptor::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 FIELD_numNodes:
            if (!strcmp(propertyname, "group")) return "fields";
            if (!strcmp(propertyname, "hint")) return "Number of nodes in this topology object";
            return nullptr;
        case FIELD_node:
            if (!strcmp(propertyname, "sizeGetter")) return "getNumNodes";
            if (!strcmp(propertyname, "hint")) return "List of nodes in this topology object";
            return nullptr;
        default: return nullptr;
    }
}

int cTopologyDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cTopology *pp = (cTopology *)object; (void)pp;
    switch (field) {
        case FIELD_node: return pp->getNumNodes();
        default: return 0;
    }
}

const char *cTopologyDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cTopology *pp = (cTopology *)object; (void)pp;
    switch (field) {
        case FIELD_node: { const cTopology::Node * value = pp->getNode(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cTopologyDescriptor::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();
    }
    cTopology *pp = (cTopology *)object; (void)pp;
    switch (field) {
        case FIELD_numNodes: return long2string(pp->getNumNodes());
        case FIELD_node: {std::stringstream out; out << pp->getNode(i); return out.str();}
        default: return "";
    }
}

bool cTopologyDescriptor::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();
    }
    cTopology *pp = (cTopology *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cTopologyDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_node: return omnetpp::opp_typename(typeid(cTopology::Node));
        default: return nullptr;
    };
}

void *cTopologyDescriptor::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();
    }
    cTopology *pp = (cTopology *)object; (void)pp;
    switch (field) {
        case FIELD_node: return toVoidPtr(pp->getNode(i)); break;
        default: return nullptr;
    }
}

class cXMLElementDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_tagName,
        FIELD_nodeValue,
        FIELD_sourceLocation,
        FIELD_attributes,
        FIELD_children,
        FIELD_xml,
    };
  public:
    cXMLElementDescriptor();
    virtual ~cXMLElementDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cXMLElementDescriptor)

cXMLElementDescriptor::cXMLElementDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cXMLElement)), "omnetpp::cObject")
{
    propertynames = nullptr;
}

cXMLElementDescriptor::~cXMLElementDescriptor()
{
    delete[] propertynames;
}

bool cXMLElementDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cXMLElement *>(obj)!=nullptr;
}

const char **cXMLElementDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cXMLElementDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cXMLElementDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 6+basedesc->getFieldCount() : 6;
}

unsigned int cXMLElementDescriptor::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[] = {
        0,    // FIELD_tagName
        0,    // FIELD_nodeValue
        0,    // FIELD_sourceLocation
        FD_ISARRAY,    // FIELD_attributes
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_children
        0,    // FIELD_xml
    };
    return (field >= 0 && field < 6) ? fieldTypeFlags[field] : 0;
}

const char *cXMLElementDescriptor::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[] = {
        "tagName",
        "nodeValue",
        "sourceLocation",
        "attributes",
        "children",
        "xml",
    };
    return (field >= 0 && field < 6) ? fieldNames[field] : nullptr;
}

int cXMLElementDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 't' && strcmp(fieldName, "tagName") == 0) return base+0;
    if (fieldName[0] == 'n' && strcmp(fieldName, "nodeValue") == 0) return base+1;
    if (fieldName[0] == 's' && strcmp(fieldName, "sourceLocation") == 0) return base+2;
    if (fieldName[0] == 'a' && strcmp(fieldName, "attributes") == 0) return base+3;
    if (fieldName[0] == 'c' && strcmp(fieldName, "children") == 0) return base+4;
    if (fieldName[0] == 'x' && strcmp(fieldName, "xml") == 0) return base+5;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cXMLElementDescriptor::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",    // FIELD_tagName
        "string",    // FIELD_nodeValue
        "string",    // FIELD_sourceLocation
        "string",    // FIELD_attributes
        "omnetpp::cXMLElement",    // FIELD_children
        "string",    // FIELD_xml
    };
    return (field >= 0 && field < 6) ? fieldTypeStrings[field] : nullptr;
}

const char **cXMLElementDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_tagName: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_nodeValue: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_sourceLocation: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        case FIELD_attributes: {
            static const char *names[] = { "getter", "sizeGetter", "hint",  nullptr };
            return names;
        }
        case FIELD_children: {
            static const char *names[] = { "getter", "sizeGetter", "hint",  nullptr };
            return names;
        }
        case FIELD_xml: {
            static const char *names[] = { "getter", "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cXMLElementDescriptor::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 FIELD_tagName:
            if (!strcmp(propertyname, "hint")) return "XML element tag";
            return nullptr;
        case FIELD_nodeValue:
            if (!strcmp(propertyname, "hint")) return "Contents of text node inside this XML element";
            return nullptr;
        case FIELD_sourceLocation:
            if (!strcmp(propertyname, "hint")) return "Location this XML element was parsed from";
            return nullptr;
        case FIELD_attributes:
            if (!strcmp(propertyname, "getter")) return "getAttr";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumAttrs";
            if (!strcmp(propertyname, "hint")) return "Attributes";
            return nullptr;
        case FIELD_children:
            if (!strcmp(propertyname, "getter")) return "getChild";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumChildren";
            if (!strcmp(propertyname, "hint")) return "Child elements";
            return nullptr;
        case FIELD_xml:
            if (!strcmp(propertyname, "getter")) return "getXML";
            if (!strcmp(propertyname, "hint")) return "Element tree as XML fragment";
            return nullptr;
        default: return nullptr;
    }
}

int cXMLElementDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cXMLElement *pp = (cXMLElement *)object; (void)pp;
    switch (field) {
        case FIELD_attributes: return pp->getNumAttrs();
        case FIELD_children: return pp->getNumChildren();
        default: return 0;
    }
}

const char *cXMLElementDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cXMLElement *pp = (cXMLElement *)object; (void)pp;
    switch (field) {
        case FIELD_children: { const cXMLElement * value = pp->getChild(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cXMLElementDescriptor::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();
    }
    cXMLElement *pp = (cXMLElement *)object; (void)pp;
    switch (field) {
        case FIELD_tagName: return oppstring2string(pp->getTagName());
        case FIELD_nodeValue: return oppstring2string(pp->getNodeValue());
        case FIELD_sourceLocation: return oppstring2string(pp->getSourceLocation());
        case FIELD_attributes: return oppstring2string(pp->getAttr(i));
        case FIELD_children: {std::stringstream out; out << pp->getChild(i); return out.str();}
        case FIELD_xml: return oppstring2string(pp->getXML());
        default: return "";
    }
}

bool cXMLElementDescriptor::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();
    }
    cXMLElement *pp = (cXMLElement *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cXMLElementDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_children: return omnetpp::opp_typename(typeid(cXMLElement));
        default: return nullptr;
    };
}

void *cXMLElementDescriptor::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();
    }
    cXMLElement *pp = (cXMLElement *)object; (void)pp;
    switch (field) {
        case FIELD_children: return toVoidPtr(pp->getChild(i)); break;
        default: return nullptr;
    }
}

class cFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_id,
        FIELD_visible,
        FIELD_zIndex,
        FIELD_tooltip,
        FIELD_associatedObject,
        FIELD_tags,
        FIELD_transform,
        FIELD_children,
    };
  public:
    cFigureDescriptor();
    virtual ~cFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cFigureDescriptor)

cFigureDescriptor::cFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cFigure)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

cFigureDescriptor::~cFigureDescriptor()
{
    delete[] propertynames;
}

bool cFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cFigure *>(obj)!=nullptr;
}

const char **cFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 8+basedesc->getFieldCount() : 8;
}

unsigned int cFigureDescriptor::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[] = {
        0,    // FIELD_id
        FD_ISEDITABLE,    // FIELD_visible
        FD_ISEDITABLE,    // FIELD_zIndex
        FD_ISEDITABLE,    // FIELD_tooltip
        FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT,    // FIELD_associatedObject
        FD_ISEDITABLE,    // FIELD_tags
        FD_ISEDITABLE,    // FIELD_transform
        FD_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_children
    };
    return (field >= 0 && field < 8) ? fieldTypeFlags[field] : 0;
}

const char *cFigureDescriptor::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[] = {
        "id",
        "visible",
        "zIndex",
        "tooltip",
        "associatedObject",
        "tags",
        "transform",
        "children",
    };
    return (field >= 0 && field < 8) ? fieldNames[field] : nullptr;
}

int cFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "id") == 0) return base+0;
    if (fieldName[0] == 'v' && strcmp(fieldName, "visible") == 0) return base+1;
    if (fieldName[0] == 'z' && strcmp(fieldName, "zIndex") == 0) return base+2;
    if (fieldName[0] == 't' && strcmp(fieldName, "tooltip") == 0) return base+3;
    if (fieldName[0] == 'a' && strcmp(fieldName, "associatedObject") == 0) return base+4;
    if (fieldName[0] == 't' && strcmp(fieldName, "tags") == 0) return base+5;
    if (fieldName[0] == 't' && strcmp(fieldName, "transform") == 0) return base+6;
    if (fieldName[0] == 'c' && strcmp(fieldName, "children") == 0) return base+7;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cFigureDescriptor::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[] = {
        "int",    // FIELD_id
        "bool",    // FIELD_visible
        "double",    // FIELD_zIndex
        "string",    // FIELD_tooltip
        "omnetpp::cObject",    // FIELD_associatedObject
        "string",    // FIELD_tags
        "omnetpp::cFigure::Transform",    // FIELD_transform
        "omnetpp::cFigure",    // FIELD_children
    };
    return (field >= 0 && field < 8) ? fieldTypeStrings[field] : nullptr;
}

const char **cFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_id: {
            static const char *names[] = { "group",  nullptr };
            return names;
        }
        case FIELD_visible: {
            static const char *names[] = { "group", "getter", "editable",  nullptr };
            return names;
        }
        case FIELD_zIndex: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_tooltip: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_associatedObject: {
            static const char *names[] = { "group",  nullptr };
            return names;
        }
        case FIELD_tags: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_transform: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_children: {
            static const char *names[] = { "group", "getter", "sizeGetter",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cFigureDescriptor::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 FIELD_id:
            if (!strcmp(propertyname, "group")) return "figure";
            return nullptr;
        case FIELD_visible:
            if (!strcmp(propertyname, "group")) return "figure";
            if (!strcmp(propertyname, "getter")) return "isVisible";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_zIndex:
            if (!strcmp(propertyname, "group")) return "figure";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_tooltip:
            if (!strcmp(propertyname, "group")) return "figure";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_associatedObject:
            if (!strcmp(propertyname, "group")) return "figure";
            return nullptr;
        case FIELD_tags:
            if (!strcmp(propertyname, "group")) return "figure";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_transform:
            if (!strcmp(propertyname, "group")) return "figure";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_children:
            if (!strcmp(propertyname, "group")) return "figure";
            if (!strcmp(propertyname, "getter")) return "getFigure";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumFigures";
            return nullptr;
        default: return nullptr;
    }
}

int cFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cFigure *pp = (cFigure *)object; (void)pp;
    switch (field) {
        case FIELD_children: return pp->getNumFigures();
        default: return 0;
    }
}

const char *cFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cFigure *pp = (cFigure *)object; (void)pp;
    switch (field) {
        case FIELD_associatedObject: { const cObject * value = pp->getAssociatedObject(); return omnetpp::opp_typename(typeid(*value)); }
        case FIELD_children: { const cFigure * value = pp->getFigure(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cFigureDescriptor::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();
    }
    cFigure *pp = (cFigure *)object; (void)pp;
    switch (field) {
        case FIELD_id: return long2string(pp->getId());
        case FIELD_visible: return bool2string(pp->isVisible());
        case FIELD_zIndex: return double2string(pp->getZIndex());
        case FIELD_tooltip: return oppstring2string(pp->getTooltip());
        case FIELD_associatedObject: {std::stringstream out; out << pp->getAssociatedObject(); return out.str();}
        case FIELD_tags: return oppstring2string(pp->getTags());
        case FIELD_transform: return pp->getTransform().str();
        case FIELD_children: {std::stringstream out; out << pp->getFigure(i); return out.str();}
        default: return "";
    }
}

bool cFigureDescriptor::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();
    }
    cFigure *pp = (cFigure *)object; (void)pp;
    switch (field) {
        case FIELD_visible: pp->setVisible(string2bool(value)); return true;
        case FIELD_zIndex: pp->setZIndex(string2double(value)); return true;
        case FIELD_tooltip: pp->setTooltip((value)); return true;
        case FIELD_tags: pp->setTags((value)); return true;
        case FIELD_transform: pp->setTransform(cFigure::parseTransform(value)); return true;
        default: return false;
    }
}

const char *cFigureDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_associatedObject: return omnetpp::opp_typename(typeid(cObject));
        case FIELD_children: return omnetpp::opp_typename(typeid(cFigure));
        default: return nullptr;
    };
}

void *cFigureDescriptor::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();
    }
    cFigure *pp = (cFigure *)object; (void)pp;
    switch (field) {
        case FIELD_associatedObject: return toVoidPtr(pp->getAssociatedObject()); break;
        case FIELD_transform: return toVoidPtr(&pp->getTransform()); break;
        case FIELD_children: return toVoidPtr(pp->getFigure(i)); break;
        default: return nullptr;
    }
}

class cGroupFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cGroupFigureDescriptor();
    virtual ~cGroupFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cGroupFigureDescriptor)

cGroupFigureDescriptor::cGroupFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cGroupFigure)), "omnetpp::cFigure")
{
    propertynames = nullptr;
}

cGroupFigureDescriptor::~cGroupFigureDescriptor()
{
    delete[] propertynames;
}

bool cGroupFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cGroupFigure *>(obj)!=nullptr;
}

const char **cGroupFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cGroupFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cGroupFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int cGroupFigureDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cGroupFigureDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cGroupFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cGroupFigureDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cGroupFigureDescriptor::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 *cGroupFigureDescriptor::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 cGroupFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cGroupFigure *pp = (cGroupFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cGroupFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cGroupFigure *pp = (cGroupFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cGroupFigureDescriptor::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();
    }
    cGroupFigure *pp = (cGroupFigure *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cGroupFigureDescriptor::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();
    }
    cGroupFigure *pp = (cGroupFigure *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cGroupFigureDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cGroupFigureDescriptor::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();
    }
    cGroupFigure *pp = (cGroupFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cPanelFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_position,
        FIELD_anchorPoint,
    };
  public:
    cPanelFigureDescriptor();
    virtual ~cPanelFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPanelFigureDescriptor)

cPanelFigureDescriptor::cPanelFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPanelFigure)), "omnetpp::cFigure")
{
    propertynames = nullptr;
}

cPanelFigureDescriptor::~cPanelFigureDescriptor()
{
    delete[] propertynames;
}

bool cPanelFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cPanelFigure *>(obj)!=nullptr;
}

const char **cPanelFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cPanelFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cPanelFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 2+basedesc->getFieldCount() : 2;
}

unsigned int cPanelFigureDescriptor::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,    // FIELD_position
        FD_ISEDITABLE,    // FIELD_anchorPoint
    };
    return (field >= 0 && field < 2) ? fieldTypeFlags[field] : 0;
}

const char *cPanelFigureDescriptor::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[] = {
        "position",
        "anchorPoint",
    };
    return (field >= 0 && field < 2) ? fieldNames[field] : nullptr;
}

int cPanelFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'p' && strcmp(fieldName, "position") == 0) return base+0;
    if (fieldName[0] == 'a' && strcmp(fieldName, "anchorPoint") == 0) return base+1;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cPanelFigureDescriptor::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[] = {
        "omnetpp::cFigure::Point",    // FIELD_position
        "omnetpp::cFigure::Point",    // FIELD_anchorPoint
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **cPanelFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_position: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_anchorPoint: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cPanelFigureDescriptor::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 FIELD_position:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_anchorPoint:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cPanelFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cPanelFigure *pp = (cPanelFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cPanelFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPanelFigure *pp = (cPanelFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPanelFigureDescriptor::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();
    }
    cPanelFigure *pp = (cPanelFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: return pp->getPosition().str();
        case FIELD_anchorPoint: return pp->getAnchorPoint().str();
        default: return "";
    }
}

bool cPanelFigureDescriptor::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();
    }
    cPanelFigure *pp = (cPanelFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: pp->setPosition(cFigure::parsePoint(value)); return true;
        case FIELD_anchorPoint: pp->setAnchorPoint(cFigure::parsePoint(value)); return true;
        default: return false;
    }
}

const char *cPanelFigureDescriptor::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 *cPanelFigureDescriptor::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();
    }
    cPanelFigure *pp = (cPanelFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: return toVoidPtr(&pp->getPosition()); break;
        case FIELD_anchorPoint: return toVoidPtr(&pp->getAnchorPoint()); break;
        default: return nullptr;
    }
}

class cAbstractLineFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_lineColor,
        FIELD_lineStyle,
        FIELD_lineWidth,
        FIELD_lineOpacity,
        FIELD_capStyle,
        FIELD_startArrowhead,
        FIELD_endArrowhead,
        FIELD_zoomLineWidth,
    };
  public:
    cAbstractLineFigureDescriptor();
    virtual ~cAbstractLineFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cAbstractLineFigureDescriptor)

cAbstractLineFigureDescriptor::cAbstractLineFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cAbstractLineFigure)), "omnetpp::cFigure")
{
    propertynames = nullptr;
}

cAbstractLineFigureDescriptor::~cAbstractLineFigureDescriptor()
{
    delete[] propertynames;
}

bool cAbstractLineFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cAbstractLineFigure *>(obj)!=nullptr;
}

const char **cAbstractLineFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cAbstractLineFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cAbstractLineFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 8+basedesc->getFieldCount() : 8;
}

unsigned int cAbstractLineFigureDescriptor::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,    // FIELD_lineColor
        FD_ISEDITABLE,    // FIELD_lineStyle
        FD_ISEDITABLE,    // FIELD_lineWidth
        FD_ISEDITABLE,    // FIELD_lineOpacity
        FD_ISEDITABLE,    // FIELD_capStyle
        FD_ISEDITABLE,    // FIELD_startArrowhead
        FD_ISEDITABLE,    // FIELD_endArrowhead
        FD_ISEDITABLE,    // FIELD_zoomLineWidth
    };
    return (field >= 0 && field < 8) ? fieldTypeFlags[field] : 0;
}

const char *cAbstractLineFigureDescriptor::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[] = {
        "lineColor",
        "lineStyle",
        "lineWidth",
        "lineOpacity",
        "capStyle",
        "startArrowhead",
        "endArrowhead",
        "zoomLineWidth",
    };
    return (field >= 0 && field < 8) ? fieldNames[field] : nullptr;
}

int cAbstractLineFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lineColor") == 0) return base+0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lineStyle") == 0) return base+1;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lineWidth") == 0) return base+2;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lineOpacity") == 0) return base+3;
    if (fieldName[0] == 'c' && strcmp(fieldName, "capStyle") == 0) return base+4;
    if (fieldName[0] == 's' && strcmp(fieldName, "startArrowhead") == 0) return base+5;
    if (fieldName[0] == 'e' && strcmp(fieldName, "endArrowhead") == 0) return base+6;
    if (fieldName[0] == 'z' && strcmp(fieldName, "zoomLineWidth") == 0) return base+7;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cAbstractLineFigureDescriptor::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[] = {
        "omnetpp::cFigure::Color",    // FIELD_lineColor
        "int",    // FIELD_lineStyle
        "double",    // FIELD_lineWidth
        "double",    // FIELD_lineOpacity
        "int",    // FIELD_capStyle
        "int",    // FIELD_startArrowhead
        "int",    // FIELD_endArrowhead
        "bool",    // FIELD_zoomLineWidth
    };
    return (field >= 0 && field < 8) ? fieldTypeStrings[field] : nullptr;
}

const char **cAbstractLineFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_lineColor: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_lineStyle: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_lineWidth: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_lineOpacity: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_capStyle: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_startArrowhead: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_endArrowhead: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_zoomLineWidth: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cAbstractLineFigureDescriptor::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 FIELD_lineColor:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_lineStyle:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::LineStyle";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::LineStyle";
            return nullptr;
        case FIELD_lineWidth:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_lineOpacity:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_capStyle:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::CapStyle";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::CapStyle";
            return nullptr;
        case FIELD_startArrowhead:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::Arrowhead";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::Arrowhead";
            return nullptr;
        case FIELD_endArrowhead:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::Arrowhead";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::Arrowhead";
            return nullptr;
        case FIELD_zoomLineWidth:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cAbstractLineFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cAbstractLineFigure *pp = (cAbstractLineFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cAbstractLineFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cAbstractLineFigure *pp = (cAbstractLineFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cAbstractLineFigureDescriptor::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();
    }
    cAbstractLineFigure *pp = (cAbstractLineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_lineColor: return pp->getLineColor().str();
        case FIELD_lineStyle: return enum2string(pp->getLineStyle(), "omnetpp::cFigure::LineStyle");
        case FIELD_lineWidth: return double2string(pp->getLineWidth());
        case FIELD_lineOpacity: return double2string(pp->getLineOpacity());
        case FIELD_capStyle: return enum2string(pp->getCapStyle(), "omnetpp::cFigure::CapStyle");
        case FIELD_startArrowhead: return enum2string(pp->getStartArrowhead(), "omnetpp::cFigure::Arrowhead");
        case FIELD_endArrowhead: return enum2string(pp->getEndArrowhead(), "omnetpp::cFigure::Arrowhead");
        case FIELD_zoomLineWidth: return bool2string(pp->getZoomLineWidth());
        default: return "";
    }
}

bool cAbstractLineFigureDescriptor::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();
    }
    cAbstractLineFigure *pp = (cAbstractLineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_lineColor: pp->setLineColor(cFigure::parseColor(value)); return true;
        case FIELD_lineStyle: pp->setLineStyle((omnetpp::cFigure::LineStyle)string2enum(value, "omnetpp::cFigure::LineStyle")); return true;
        case FIELD_lineWidth: pp->setLineWidth(string2double(value)); return true;
        case FIELD_lineOpacity: pp->setLineOpacity(string2double(value)); return true;
        case FIELD_capStyle: pp->setCapStyle((omnetpp::cFigure::CapStyle)string2enum(value, "omnetpp::cFigure::CapStyle")); return true;
        case FIELD_startArrowhead: pp->setStartArrowhead((omnetpp::cFigure::Arrowhead)string2enum(value, "omnetpp::cFigure::Arrowhead")); return true;
        case FIELD_endArrowhead: pp->setEndArrowhead((omnetpp::cFigure::Arrowhead)string2enum(value, "omnetpp::cFigure::Arrowhead")); return true;
        case FIELD_zoomLineWidth: pp->setZoomLineWidth(string2bool(value)); return true;
        default: return false;
    }
}

const char *cAbstractLineFigureDescriptor::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 *cAbstractLineFigureDescriptor::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();
    }
    cAbstractLineFigure *pp = (cAbstractLineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_lineColor: return toVoidPtr(&pp->getLineColor()); break;
        default: return nullptr;
    }
}

class cLineFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_start,
        FIELD_end,
    };
  public:
    cLineFigureDescriptor();
    virtual ~cLineFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cLineFigureDescriptor)

cLineFigureDescriptor::cLineFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cLineFigure)), "omnetpp::cAbstractLineFigure")
{
    propertynames = nullptr;
}

cLineFigureDescriptor::~cLineFigureDescriptor()
{
    delete[] propertynames;
}

bool cLineFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cLineFigure *>(obj)!=nullptr;
}

const char **cLineFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cLineFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cLineFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 2+basedesc->getFieldCount() : 2;
}

unsigned int cLineFigureDescriptor::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,    // FIELD_start
        FD_ISEDITABLE,    // FIELD_end
    };
    return (field >= 0 && field < 2) ? fieldTypeFlags[field] : 0;
}

const char *cLineFigureDescriptor::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[] = {
        "start",
        "end",
    };
    return (field >= 0 && field < 2) ? fieldNames[field] : nullptr;
}

int cLineFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 's' && strcmp(fieldName, "start") == 0) return base+0;
    if (fieldName[0] == 'e' && strcmp(fieldName, "end") == 0) return base+1;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cLineFigureDescriptor::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[] = {
        "omnetpp::cFigure::Point",    // FIELD_start
        "omnetpp::cFigure::Point",    // FIELD_end
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **cLineFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_start: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_end: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cLineFigureDescriptor::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 FIELD_start:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_end:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cLineFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cLineFigure *pp = (cLineFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cLineFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cLineFigure *pp = (cLineFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cLineFigureDescriptor::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();
    }
    cLineFigure *pp = (cLineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_start: return pp->getStart().str();
        case FIELD_end: return pp->getEnd().str();
        default: return "";
    }
}

bool cLineFigureDescriptor::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();
    }
    cLineFigure *pp = (cLineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_start: pp->setStart(cFigure::parsePoint(value)); return true;
        case FIELD_end: pp->setEnd(cFigure::parsePoint(value)); return true;
        default: return false;
    }
}

const char *cLineFigureDescriptor::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 *cLineFigureDescriptor::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();
    }
    cLineFigure *pp = (cLineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_start: return toVoidPtr(&pp->getStart()); break;
        case FIELD_end: return toVoidPtr(&pp->getEnd()); break;
        default: return nullptr;
    }
}

class cArcFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_bounds,
        FIELD_startAngle,
        FIELD_endAngle,
    };
  public:
    cArcFigureDescriptor();
    virtual ~cArcFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cArcFigureDescriptor)

cArcFigureDescriptor::cArcFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cArcFigure)), "omnetpp::cAbstractLineFigure")
{
    propertynames = nullptr;
}

cArcFigureDescriptor::~cArcFigureDescriptor()
{
    delete[] propertynames;
}

bool cArcFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cArcFigure *>(obj)!=nullptr;
}

const char **cArcFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cArcFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cArcFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int cArcFigureDescriptor::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,    // FIELD_bounds
        FD_ISEDITABLE,    // FIELD_startAngle
        FD_ISEDITABLE,    // FIELD_endAngle
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cArcFigureDescriptor::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[] = {
        "bounds",
        "startAngle",
        "endAngle",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cArcFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'b' && strcmp(fieldName, "bounds") == 0) return base+0;
    if (fieldName[0] == 's' && strcmp(fieldName, "startAngle") == 0) return base+1;
    if (fieldName[0] == 'e' && strcmp(fieldName, "endAngle") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cArcFigureDescriptor::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[] = {
        "omnetpp::cFigure::Rectangle",    // FIELD_bounds
        "double",    // FIELD_startAngle
        "double",    // FIELD_endAngle
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cArcFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_bounds: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_startAngle: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_endAngle: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cArcFigureDescriptor::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 FIELD_bounds:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_startAngle:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_endAngle:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cArcFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cArcFigure *pp = (cArcFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cArcFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cArcFigure *pp = (cArcFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cArcFigureDescriptor::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();
    }
    cArcFigure *pp = (cArcFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return pp->getBounds().str();
        case FIELD_startAngle: return double2string(pp->getStartAngle());
        case FIELD_endAngle: return double2string(pp->getEndAngle());
        default: return "";
    }
}

bool cArcFigureDescriptor::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();
    }
    cArcFigure *pp = (cArcFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: pp->setBounds(cFigure::parseRectangle(value)); return true;
        case FIELD_startAngle: pp->setStartAngle(string2double(value)); return true;
        case FIELD_endAngle: pp->setEndAngle(string2double(value)); return true;
        default: return false;
    }
}

const char *cArcFigureDescriptor::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 *cArcFigureDescriptor::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();
    }
    cArcFigure *pp = (cArcFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return toVoidPtr(&pp->getBounds()); break;
        default: return nullptr;
    }
}

class cPolylineFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_points,
        FIELD_smooth,
        FIELD_joinStyle,
    };
  public:
    cPolylineFigureDescriptor();
    virtual ~cPolylineFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPolylineFigureDescriptor)

cPolylineFigureDescriptor::cPolylineFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPolylineFigure)), "omnetpp::cAbstractLineFigure")
{
    propertynames = nullptr;
}

cPolylineFigureDescriptor::~cPolylineFigureDescriptor()
{
    delete[] propertynames;
}

bool cPolylineFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cPolylineFigure *>(obj)!=nullptr;
}

const char **cPolylineFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cPolylineFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cPolylineFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int cPolylineFigureDescriptor::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_ISARRAY | FD_ISEDITABLE,    // FIELD_points
        FD_ISEDITABLE,    // FIELD_smooth
        FD_ISEDITABLE,    // FIELD_joinStyle
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cPolylineFigureDescriptor::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[] = {
        "points",
        "smooth",
        "joinStyle",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cPolylineFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'p' && strcmp(fieldName, "points") == 0) return base+0;
    if (fieldName[0] == 's' && strcmp(fieldName, "smooth") == 0) return base+1;
    if (fieldName[0] == 'j' && strcmp(fieldName, "joinStyle") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cPolylineFigureDescriptor::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[] = {
        "omnetpp::cFigure::Point",    // FIELD_points
        "bool",    // FIELD_smooth
        "int",    // FIELD_joinStyle
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cPolylineFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_points: {
            static const char *names[] = { "group", "editable", "getter", "setter", "sizeGetter",  nullptr };
            return names;
        }
        case FIELD_smooth: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_joinStyle: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cPolylineFigureDescriptor::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 FIELD_points:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "getter")) return "getPoint";
            if (!strcmp(propertyname, "setter")) return "setPoint";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumPoints";
            return nullptr;
        case FIELD_smooth:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_joinStyle:
            if (!strcmp(propertyname, "group")) return "line";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::JoinStyle";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::JoinStyle";
            return nullptr;
        default: return nullptr;
    }
}

int cPolylineFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cPolylineFigure *pp = (cPolylineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_points: return pp->getNumPoints();
        default: return 0;
    }
}

const char *cPolylineFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPolylineFigure *pp = (cPolylineFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPolylineFigureDescriptor::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();
    }
    cPolylineFigure *pp = (cPolylineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_points: return pp->getPoint(i).str();
        case FIELD_smooth: return bool2string(pp->getSmooth());
        case FIELD_joinStyle: return enum2string(pp->getJoinStyle(), "omnetpp::cFigure::JoinStyle");
        default: return "";
    }
}

bool cPolylineFigureDescriptor::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();
    }
    cPolylineFigure *pp = (cPolylineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_points: pp->setPoint(i,cFigure::parsePoint(value)); return true;
        case FIELD_smooth: pp->setSmooth(string2bool(value)); return true;
        case FIELD_joinStyle: pp->setJoinStyle((omnetpp::cFigure::JoinStyle)string2enum(value, "omnetpp::cFigure::JoinStyle")); return true;
        default: return false;
    }
}

const char *cPolylineFigureDescriptor::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 *cPolylineFigureDescriptor::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();
    }
    cPolylineFigure *pp = (cPolylineFigure *)object; (void)pp;
    switch (field) {
        case FIELD_points: return toVoidPtr(&pp->getPoint(i)); break;
        default: return nullptr;
    }
}

class cAbstractShapeFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_outlined,
        FIELD_filled,
        FIELD_lineColor,
        FIELD_fillColor,
        FIELD_lineStyle,
        FIELD_lineWidth,
        FIELD_lineOpacity,
        FIELD_fillOpacity,
        FIELD_zoomLineWidth,
    };
  public:
    cAbstractShapeFigureDescriptor();
    virtual ~cAbstractShapeFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cAbstractShapeFigureDescriptor)

cAbstractShapeFigureDescriptor::cAbstractShapeFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cAbstractShapeFigure)), "omnetpp::cFigure")
{
    propertynames = nullptr;
}

cAbstractShapeFigureDescriptor::~cAbstractShapeFigureDescriptor()
{
    delete[] propertynames;
}

bool cAbstractShapeFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cAbstractShapeFigure *>(obj)!=nullptr;
}

const char **cAbstractShapeFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cAbstractShapeFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cAbstractShapeFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 9+basedesc->getFieldCount() : 9;
}

unsigned int cAbstractShapeFigureDescriptor::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,    // FIELD_outlined
        FD_ISEDITABLE,    // FIELD_filled
        FD_ISEDITABLE,    // FIELD_lineColor
        FD_ISEDITABLE,    // FIELD_fillColor
        FD_ISEDITABLE,    // FIELD_lineStyle
        FD_ISEDITABLE,    // FIELD_lineWidth
        FD_ISEDITABLE,    // FIELD_lineOpacity
        FD_ISEDITABLE,    // FIELD_fillOpacity
        FD_ISEDITABLE,    // FIELD_zoomLineWidth
    };
    return (field >= 0 && field < 9) ? fieldTypeFlags[field] : 0;
}

const char *cAbstractShapeFigureDescriptor::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[] = {
        "outlined",
        "filled",
        "lineColor",
        "fillColor",
        "lineStyle",
        "lineWidth",
        "lineOpacity",
        "fillOpacity",
        "zoomLineWidth",
    };
    return (field >= 0 && field < 9) ? fieldNames[field] : nullptr;
}

int cAbstractShapeFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'o' && strcmp(fieldName, "outlined") == 0) return base+0;
    if (fieldName[0] == 'f' && strcmp(fieldName, "filled") == 0) return base+1;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lineColor") == 0) return base+2;
    if (fieldName[0] == 'f' && strcmp(fieldName, "fillColor") == 0) return base+3;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lineStyle") == 0) return base+4;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lineWidth") == 0) return base+5;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lineOpacity") == 0) return base+6;
    if (fieldName[0] == 'f' && strcmp(fieldName, "fillOpacity") == 0) return base+7;
    if (fieldName[0] == 'z' && strcmp(fieldName, "zoomLineWidth") == 0) return base+8;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cAbstractShapeFigureDescriptor::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[] = {
        "bool",    // FIELD_outlined
        "bool",    // FIELD_filled
        "omnetpp::cFigure::Color",    // FIELD_lineColor
        "omnetpp::cFigure::Color",    // FIELD_fillColor
        "int",    // FIELD_lineStyle
        "double",    // FIELD_lineWidth
        "double",    // FIELD_lineOpacity
        "double",    // FIELD_fillOpacity
        "bool",    // FIELD_zoomLineWidth
    };
    return (field >= 0 && field < 9) ? fieldTypeStrings[field] : nullptr;
}

const char **cAbstractShapeFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_outlined: {
            static const char *names[] = { "group", "getter", "editable",  nullptr };
            return names;
        }
        case FIELD_filled: {
            static const char *names[] = { "group", "getter", "editable",  nullptr };
            return names;
        }
        case FIELD_lineColor: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_fillColor: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_lineStyle: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_lineWidth: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_lineOpacity: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_fillOpacity: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_zoomLineWidth: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cAbstractShapeFigureDescriptor::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 FIELD_outlined:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "getter")) return "isOutlined";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_filled:
            if (!strcmp(propertyname, "group")) return "fill";
            if (!strcmp(propertyname, "getter")) return "isFilled";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_lineColor:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_fillColor:
            if (!strcmp(propertyname, "group")) return "fill";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_lineStyle:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::LineStyle";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::LineStyle";
            return nullptr;
        case FIELD_lineWidth:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_lineOpacity:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_fillOpacity:
            if (!strcmp(propertyname, "group")) return "fill";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_zoomLineWidth:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cAbstractShapeFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cAbstractShapeFigure *pp = (cAbstractShapeFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cAbstractShapeFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cAbstractShapeFigure *pp = (cAbstractShapeFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cAbstractShapeFigureDescriptor::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();
    }
    cAbstractShapeFigure *pp = (cAbstractShapeFigure *)object; (void)pp;
    switch (field) {
        case FIELD_outlined: return bool2string(pp->isOutlined());
        case FIELD_filled: return bool2string(pp->isFilled());
        case FIELD_lineColor: return pp->getLineColor().str();
        case FIELD_fillColor: return pp->getFillColor().str();
        case FIELD_lineStyle: return enum2string(pp->getLineStyle(), "omnetpp::cFigure::LineStyle");
        case FIELD_lineWidth: return double2string(pp->getLineWidth());
        case FIELD_lineOpacity: return double2string(pp->getLineOpacity());
        case FIELD_fillOpacity: return double2string(pp->getFillOpacity());
        case FIELD_zoomLineWidth: return bool2string(pp->getZoomLineWidth());
        default: return "";
    }
}

bool cAbstractShapeFigureDescriptor::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();
    }
    cAbstractShapeFigure *pp = (cAbstractShapeFigure *)object; (void)pp;
    switch (field) {
        case FIELD_outlined: pp->setOutlined(string2bool(value)); return true;
        case FIELD_filled: pp->setFilled(string2bool(value)); return true;
        case FIELD_lineColor: pp->setLineColor(cFigure::parseColor(value)); return true;
        case FIELD_fillColor: pp->setFillColor(cFigure::parseColor(value)); return true;
        case FIELD_lineStyle: pp->setLineStyle((omnetpp::cFigure::LineStyle)string2enum(value, "omnetpp::cFigure::LineStyle")); return true;
        case FIELD_lineWidth: pp->setLineWidth(string2double(value)); return true;
        case FIELD_lineOpacity: pp->setLineOpacity(string2double(value)); return true;
        case FIELD_fillOpacity: pp->setFillOpacity(string2double(value)); return true;
        case FIELD_zoomLineWidth: pp->setZoomLineWidth(string2bool(value)); return true;
        default: return false;
    }
}

const char *cAbstractShapeFigureDescriptor::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 *cAbstractShapeFigureDescriptor::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();
    }
    cAbstractShapeFigure *pp = (cAbstractShapeFigure *)object; (void)pp;
    switch (field) {
        case FIELD_lineColor: return toVoidPtr(&pp->getLineColor()); break;
        case FIELD_fillColor: return toVoidPtr(&pp->getFillColor()); break;
        default: return nullptr;
    }
}

class cRectangleFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_bounds,
        FIELD_cornerRx,
        FIELD_cornerRy,
    };
  public:
    cRectangleFigureDescriptor();
    virtual ~cRectangleFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cRectangleFigureDescriptor)

cRectangleFigureDescriptor::cRectangleFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cRectangleFigure)), "omnetpp::cAbstractShapeFigure")
{
    propertynames = nullptr;
}

cRectangleFigureDescriptor::~cRectangleFigureDescriptor()
{
    delete[] propertynames;
}

bool cRectangleFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cRectangleFigure *>(obj)!=nullptr;
}

const char **cRectangleFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cRectangleFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cRectangleFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int cRectangleFigureDescriptor::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,    // FIELD_bounds
        FD_ISEDITABLE,    // FIELD_cornerRx
        FD_ISEDITABLE,    // FIELD_cornerRy
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cRectangleFigureDescriptor::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[] = {
        "bounds",
        "cornerRx",
        "cornerRy",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cRectangleFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'b' && strcmp(fieldName, "bounds") == 0) return base+0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "cornerRx") == 0) return base+1;
    if (fieldName[0] == 'c' && strcmp(fieldName, "cornerRy") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cRectangleFigureDescriptor::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[] = {
        "omnetpp::cFigure::Rectangle",    // FIELD_bounds
        "double",    // FIELD_cornerRx
        "double",    // FIELD_cornerRy
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cRectangleFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_bounds: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_cornerRx: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_cornerRy: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cRectangleFigureDescriptor::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 FIELD_bounds:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_cornerRx:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_cornerRy:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cRectangleFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cRectangleFigure *pp = (cRectangleFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cRectangleFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cRectangleFigure *pp = (cRectangleFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cRectangleFigureDescriptor::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();
    }
    cRectangleFigure *pp = (cRectangleFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return pp->getBounds().str();
        case FIELD_cornerRx: return double2string(pp->getCornerRx());
        case FIELD_cornerRy: return double2string(pp->getCornerRy());
        default: return "";
    }
}

bool cRectangleFigureDescriptor::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();
    }
    cRectangleFigure *pp = (cRectangleFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: pp->setBounds(cFigure::parseRectangle(value)); return true;
        case FIELD_cornerRx: pp->setCornerRx(string2double(value)); return true;
        case FIELD_cornerRy: pp->setCornerRy(string2double(value)); return true;
        default: return false;
    }
}

const char *cRectangleFigureDescriptor::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 *cRectangleFigureDescriptor::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();
    }
    cRectangleFigure *pp = (cRectangleFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return toVoidPtr(&pp->getBounds()); break;
        default: return nullptr;
    }
}

class cOvalFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_bounds,
    };
  public:
    cOvalFigureDescriptor();
    virtual ~cOvalFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cOvalFigureDescriptor)

cOvalFigureDescriptor::cOvalFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cOvalFigure)), "omnetpp::cAbstractShapeFigure")
{
    propertynames = nullptr;
}

cOvalFigureDescriptor::~cOvalFigureDescriptor()
{
    delete[] propertynames;
}

bool cOvalFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cOvalFigure *>(obj)!=nullptr;
}

const char **cOvalFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cOvalFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cOvalFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int cOvalFigureDescriptor::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,    // FIELD_bounds
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *cOvalFigureDescriptor::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[] = {
        "bounds",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int cOvalFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'b' && strcmp(fieldName, "bounds") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cOvalFigureDescriptor::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[] = {
        "omnetpp::cFigure::Rectangle",    // FIELD_bounds
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **cOvalFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_bounds: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cOvalFigureDescriptor::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 FIELD_bounds:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cOvalFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cOvalFigure *pp = (cOvalFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cOvalFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cOvalFigure *pp = (cOvalFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cOvalFigureDescriptor::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();
    }
    cOvalFigure *pp = (cOvalFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return pp->getBounds().str();
        default: return "";
    }
}

bool cOvalFigureDescriptor::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();
    }
    cOvalFigure *pp = (cOvalFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: pp->setBounds(cFigure::parseRectangle(value)); return true;
        default: return false;
    }
}

const char *cOvalFigureDescriptor::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 *cOvalFigureDescriptor::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();
    }
    cOvalFigure *pp = (cOvalFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return toVoidPtr(&pp->getBounds()); break;
        default: return nullptr;
    }
}

class cRingFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_bounds,
        FIELD_innerRx,
        FIELD_innerRy,
    };
  public:
    cRingFigureDescriptor();
    virtual ~cRingFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cRingFigureDescriptor)

cRingFigureDescriptor::cRingFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cRingFigure)), "omnetpp::cAbstractShapeFigure")
{
    propertynames = nullptr;
}

cRingFigureDescriptor::~cRingFigureDescriptor()
{
    delete[] propertynames;
}

bool cRingFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cRingFigure *>(obj)!=nullptr;
}

const char **cRingFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cRingFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cRingFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int cRingFigureDescriptor::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,    // FIELD_bounds
        FD_ISEDITABLE,    // FIELD_innerRx
        FD_ISEDITABLE,    // FIELD_innerRy
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cRingFigureDescriptor::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[] = {
        "bounds",
        "innerRx",
        "innerRy",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cRingFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'b' && strcmp(fieldName, "bounds") == 0) return base+0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "innerRx") == 0) return base+1;
    if (fieldName[0] == 'i' && strcmp(fieldName, "innerRy") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cRingFigureDescriptor::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[] = {
        "omnetpp::cFigure::Rectangle",    // FIELD_bounds
        "double",    // FIELD_innerRx
        "double",    // FIELD_innerRy
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cRingFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_bounds: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_innerRx: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_innerRy: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cRingFigureDescriptor::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 FIELD_bounds:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_innerRx:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_innerRy:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cRingFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cRingFigure *pp = (cRingFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cRingFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cRingFigure *pp = (cRingFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cRingFigureDescriptor::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();
    }
    cRingFigure *pp = (cRingFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return pp->getBounds().str();
        case FIELD_innerRx: return double2string(pp->getInnerRx());
        case FIELD_innerRy: return double2string(pp->getInnerRy());
        default: return "";
    }
}

bool cRingFigureDescriptor::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();
    }
    cRingFigure *pp = (cRingFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: pp->setBounds(cFigure::parseRectangle(value)); return true;
        case FIELD_innerRx: pp->setInnerRx(string2double(value)); return true;
        case FIELD_innerRy: pp->setInnerRy(string2double(value)); return true;
        default: return false;
    }
}

const char *cRingFigureDescriptor::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 *cRingFigureDescriptor::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();
    }
    cRingFigure *pp = (cRingFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return toVoidPtr(&pp->getBounds()); break;
        default: return nullptr;
    }
}

class cPieSliceFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_bounds,
        FIELD_startAngle,
        FIELD_endAngle,
    };
  public:
    cPieSliceFigureDescriptor();
    virtual ~cPieSliceFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPieSliceFigureDescriptor)

cPieSliceFigureDescriptor::cPieSliceFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPieSliceFigure)), "omnetpp::cAbstractShapeFigure")
{
    propertynames = nullptr;
}

cPieSliceFigureDescriptor::~cPieSliceFigureDescriptor()
{
    delete[] propertynames;
}

bool cPieSliceFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cPieSliceFigure *>(obj)!=nullptr;
}

const char **cPieSliceFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cPieSliceFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cPieSliceFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int cPieSliceFigureDescriptor::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,    // FIELD_bounds
        FD_ISEDITABLE,    // FIELD_startAngle
        FD_ISEDITABLE,    // FIELD_endAngle
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cPieSliceFigureDescriptor::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[] = {
        "bounds",
        "startAngle",
        "endAngle",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cPieSliceFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'b' && strcmp(fieldName, "bounds") == 0) return base+0;
    if (fieldName[0] == 's' && strcmp(fieldName, "startAngle") == 0) return base+1;
    if (fieldName[0] == 'e' && strcmp(fieldName, "endAngle") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cPieSliceFigureDescriptor::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[] = {
        "omnetpp::cFigure::Rectangle",    // FIELD_bounds
        "double",    // FIELD_startAngle
        "double",    // FIELD_endAngle
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cPieSliceFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_bounds: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_startAngle: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_endAngle: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cPieSliceFigureDescriptor::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 FIELD_bounds:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_startAngle:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_endAngle:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cPieSliceFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cPieSliceFigure *pp = (cPieSliceFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cPieSliceFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPieSliceFigure *pp = (cPieSliceFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPieSliceFigureDescriptor::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();
    }
    cPieSliceFigure *pp = (cPieSliceFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return pp->getBounds().str();
        case FIELD_startAngle: return double2string(pp->getStartAngle());
        case FIELD_endAngle: return double2string(pp->getEndAngle());
        default: return "";
    }
}

bool cPieSliceFigureDescriptor::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();
    }
    cPieSliceFigure *pp = (cPieSliceFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: pp->setBounds(cFigure::parseRectangle(value)); return true;
        case FIELD_startAngle: pp->setStartAngle(string2double(value)); return true;
        case FIELD_endAngle: pp->setEndAngle(string2double(value)); return true;
        default: return false;
    }
}

const char *cPieSliceFigureDescriptor::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 *cPieSliceFigureDescriptor::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();
    }
    cPieSliceFigure *pp = (cPieSliceFigure *)object; (void)pp;
    switch (field) {
        case FIELD_bounds: return toVoidPtr(&pp->getBounds()); break;
        default: return nullptr;
    }
}

class cPolygonFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_points,
        FIELD_smooth,
        FIELD_joinStyle,
        FIELD_fillRule,
    };
  public:
    cPolygonFigureDescriptor();
    virtual ~cPolygonFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPolygonFigureDescriptor)

cPolygonFigureDescriptor::cPolygonFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPolygonFigure)), "omnetpp::cAbstractShapeFigure")
{
    propertynames = nullptr;
}

cPolygonFigureDescriptor::~cPolygonFigureDescriptor()
{
    delete[] propertynames;
}

bool cPolygonFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cPolygonFigure *>(obj)!=nullptr;
}

const char **cPolygonFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cPolygonFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cPolygonFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 4+basedesc->getFieldCount() : 4;
}

unsigned int cPolygonFigureDescriptor::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_ISARRAY | FD_ISEDITABLE,    // FIELD_points
        FD_ISEDITABLE,    // FIELD_smooth
        FD_ISEDITABLE,    // FIELD_joinStyle
        FD_ISEDITABLE,    // FIELD_fillRule
    };
    return (field >= 0 && field < 4) ? fieldTypeFlags[field] : 0;
}

const char *cPolygonFigureDescriptor::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[] = {
        "points",
        "smooth",
        "joinStyle",
        "fillRule",
    };
    return (field >= 0 && field < 4) ? fieldNames[field] : nullptr;
}

int cPolygonFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'p' && strcmp(fieldName, "points") == 0) return base+0;
    if (fieldName[0] == 's' && strcmp(fieldName, "smooth") == 0) return base+1;
    if (fieldName[0] == 'j' && strcmp(fieldName, "joinStyle") == 0) return base+2;
    if (fieldName[0] == 'f' && strcmp(fieldName, "fillRule") == 0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cPolygonFigureDescriptor::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[] = {
        "omnetpp::cFigure::Point",    // FIELD_points
        "bool",    // FIELD_smooth
        "int",    // FIELD_joinStyle
        "int",    // FIELD_fillRule
    };
    return (field >= 0 && field < 4) ? fieldTypeStrings[field] : nullptr;
}

const char **cPolygonFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_points: {
            static const char *names[] = { "group", "editable", "getter", "setter", "sizeGetter",  nullptr };
            return names;
        }
        case FIELD_smooth: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_joinStyle: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_fillRule: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cPolygonFigureDescriptor::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 FIELD_points:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "getter")) return "getPoint";
            if (!strcmp(propertyname, "setter")) return "setPoint";
            if (!strcmp(propertyname, "sizeGetter")) return "getNumPoints";
            return nullptr;
        case FIELD_smooth:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_joinStyle:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::JoinStyle";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::JoinStyle";
            return nullptr;
        case FIELD_fillRule:
            if (!strcmp(propertyname, "group")) return "fill";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::FillRule";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::FillRule";
            return nullptr;
        default: return nullptr;
    }
}

int cPolygonFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cPolygonFigure *pp = (cPolygonFigure *)object; (void)pp;
    switch (field) {
        case FIELD_points: return pp->getNumPoints();
        default: return 0;
    }
}

const char *cPolygonFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPolygonFigure *pp = (cPolygonFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPolygonFigureDescriptor::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();
    }
    cPolygonFigure *pp = (cPolygonFigure *)object; (void)pp;
    switch (field) {
        case FIELD_points: return pp->getPoint(i).str();
        case FIELD_smooth: return bool2string(pp->getSmooth());
        case FIELD_joinStyle: return enum2string(pp->getJoinStyle(), "omnetpp::cFigure::JoinStyle");
        case FIELD_fillRule: return enum2string(pp->getFillRule(), "omnetpp::cFigure::FillRule");
        default: return "";
    }
}

bool cPolygonFigureDescriptor::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();
    }
    cPolygonFigure *pp = (cPolygonFigure *)object; (void)pp;
    switch (field) {
        case FIELD_points: pp->setPoint(i,cFigure::parsePoint(value)); return true;
        case FIELD_smooth: pp->setSmooth(string2bool(value)); return true;
        case FIELD_joinStyle: pp->setJoinStyle((omnetpp::cFigure::JoinStyle)string2enum(value, "omnetpp::cFigure::JoinStyle")); return true;
        case FIELD_fillRule: pp->setFillRule((omnetpp::cFigure::FillRule)string2enum(value, "omnetpp::cFigure::FillRule")); return true;
        default: return false;
    }
}

const char *cPolygonFigureDescriptor::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 *cPolygonFigureDescriptor::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();
    }
    cPolygonFigure *pp = (cPolygonFigure *)object; (void)pp;
    switch (field) {
        case FIELD_points: return toVoidPtr(&pp->getPoint(i)); break;
        default: return nullptr;
    }
}

class cPathFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_path,
        FIELD_offset,
        FIELD_joinStyle,
        FIELD_capStyle,
        FIELD_fillRule,
    };
  public:
    cPathFigureDescriptor();
    virtual ~cPathFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPathFigureDescriptor)

cPathFigureDescriptor::cPathFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPathFigure)), "omnetpp::cAbstractShapeFigure")
{
    propertynames = nullptr;
}

cPathFigureDescriptor::~cPathFigureDescriptor()
{
    delete[] propertynames;
}

bool cPathFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cPathFigure *>(obj)!=nullptr;
}

const char **cPathFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cPathFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cPathFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 5+basedesc->getFieldCount() : 5;
}

unsigned int cPathFigureDescriptor::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,    // FIELD_path
        FD_ISEDITABLE,    // FIELD_offset
        FD_ISEDITABLE,    // FIELD_joinStyle
        FD_ISEDITABLE,    // FIELD_capStyle
        FD_ISEDITABLE,    // FIELD_fillRule
    };
    return (field >= 0 && field < 5) ? fieldTypeFlags[field] : 0;
}

const char *cPathFigureDescriptor::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[] = {
        "path",
        "offset",
        "joinStyle",
        "capStyle",
        "fillRule",
    };
    return (field >= 0 && field < 5) ? fieldNames[field] : nullptr;
}

int cPathFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'p' && strcmp(fieldName, "path") == 0) return base+0;
    if (fieldName[0] == 'o' && strcmp(fieldName, "offset") == 0) return base+1;
    if (fieldName[0] == 'j' && strcmp(fieldName, "joinStyle") == 0) return base+2;
    if (fieldName[0] == 'c' && strcmp(fieldName, "capStyle") == 0) return base+3;
    if (fieldName[0] == 'f' && strcmp(fieldName, "fillRule") == 0) return base+4;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cPathFigureDescriptor::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",    // FIELD_path
        "omnetpp::cFigure::Point",    // FIELD_offset
        "int",    // FIELD_joinStyle
        "int",    // FIELD_capStyle
        "int",    // FIELD_fillRule
    };
    return (field >= 0 && field < 5) ? fieldTypeStrings[field] : nullptr;
}

const char **cPathFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_path: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_offset: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_joinStyle: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_capStyle: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_fillRule: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cPathFigureDescriptor::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 FIELD_path:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_offset:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_joinStyle:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::JoinStyle";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::JoinStyle";
            return nullptr;
        case FIELD_capStyle:
            if (!strcmp(propertyname, "group")) return "outline";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::CapStyle";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::CapStyle";
            return nullptr;
        case FIELD_fillRule:
            if (!strcmp(propertyname, "group")) return "fill";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::FillRule";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::FillRule";
            return nullptr;
        default: return nullptr;
    }
}

int cPathFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cPathFigure *pp = (cPathFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cPathFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPathFigure *pp = (cPathFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPathFigureDescriptor::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();
    }
    cPathFigure *pp = (cPathFigure *)object; (void)pp;
    switch (field) {
        case FIELD_path: return oppstring2string(pp->getPath());
        case FIELD_offset: return pp->getOffset().str();
        case FIELD_joinStyle: return enum2string(pp->getJoinStyle(), "omnetpp::cFigure::JoinStyle");
        case FIELD_capStyle: return enum2string(pp->getCapStyle(), "omnetpp::cFigure::CapStyle");
        case FIELD_fillRule: return enum2string(pp->getFillRule(), "omnetpp::cFigure::FillRule");
        default: return "";
    }
}

bool cPathFigureDescriptor::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();
    }
    cPathFigure *pp = (cPathFigure *)object; (void)pp;
    switch (field) {
        case FIELD_path: pp->setPath((value)); return true;
        case FIELD_offset: pp->setOffset(cFigure::parsePoint(value)); return true;
        case FIELD_joinStyle: pp->setJoinStyle((omnetpp::cFigure::JoinStyle)string2enum(value, "omnetpp::cFigure::JoinStyle")); return true;
        case FIELD_capStyle: pp->setCapStyle((omnetpp::cFigure::CapStyle)string2enum(value, "omnetpp::cFigure::CapStyle")); return true;
        case FIELD_fillRule: pp->setFillRule((omnetpp::cFigure::FillRule)string2enum(value, "omnetpp::cFigure::FillRule")); return true;
        default: return false;
    }
}

const char *cPathFigureDescriptor::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 *cPathFigureDescriptor::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();
    }
    cPathFigure *pp = (cPathFigure *)object; (void)pp;
    switch (field) {
        case FIELD_offset: return toVoidPtr(&pp->getOffset()); break;
        default: return nullptr;
    }
}

class cAbstractTextFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_position,
        FIELD_anchor,
        FIELD_text,
        FIELD_font,
        FIELD_color,
        FIELD_opacity,
        FIELD_halo,
    };
  public:
    cAbstractTextFigureDescriptor();
    virtual ~cAbstractTextFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cAbstractTextFigureDescriptor)

cAbstractTextFigureDescriptor::cAbstractTextFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cAbstractTextFigure)), "omnetpp::cFigure")
{
    propertynames = nullptr;
}

cAbstractTextFigureDescriptor::~cAbstractTextFigureDescriptor()
{
    delete[] propertynames;
}

bool cAbstractTextFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cAbstractTextFigure *>(obj)!=nullptr;
}

const char **cAbstractTextFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cAbstractTextFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cAbstractTextFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 7+basedesc->getFieldCount() : 7;
}

unsigned int cAbstractTextFigureDescriptor::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,    // FIELD_position
        FD_ISEDITABLE,    // FIELD_anchor
        FD_ISEDITABLE,    // FIELD_text
        FD_ISEDITABLE,    // FIELD_font
        FD_ISEDITABLE,    // FIELD_color
        FD_ISEDITABLE,    // FIELD_opacity
        FD_ISEDITABLE,    // FIELD_halo
    };
    return (field >= 0 && field < 7) ? fieldTypeFlags[field] : 0;
}

const char *cAbstractTextFigureDescriptor::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[] = {
        "position",
        "anchor",
        "text",
        "font",
        "color",
        "opacity",
        "halo",
    };
    return (field >= 0 && field < 7) ? fieldNames[field] : nullptr;
}

int cAbstractTextFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'p' && strcmp(fieldName, "position") == 0) return base+0;
    if (fieldName[0] == 'a' && strcmp(fieldName, "anchor") == 0) return base+1;
    if (fieldName[0] == 't' && strcmp(fieldName, "text") == 0) return base+2;
    if (fieldName[0] == 'f' && strcmp(fieldName, "font") == 0) return base+3;
    if (fieldName[0] == 'c' && strcmp(fieldName, "color") == 0) return base+4;
    if (fieldName[0] == 'o' && strcmp(fieldName, "opacity") == 0) return base+5;
    if (fieldName[0] == 'h' && strcmp(fieldName, "halo") == 0) return base+6;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cAbstractTextFigureDescriptor::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[] = {
        "omnetpp::cFigure::Point",    // FIELD_position
        "int",    // FIELD_anchor
        "string",    // FIELD_text
        "omnetpp::cFigure::Font",    // FIELD_font
        "omnetpp::cFigure::Color",    // FIELD_color
        "double",    // FIELD_opacity
        "bool",    // FIELD_halo
    };
    return (field >= 0 && field < 7) ? fieldTypeStrings[field] : nullptr;
}

const char **cAbstractTextFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_position: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_anchor: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_text: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_font: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_color: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_opacity: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_halo: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cAbstractTextFigureDescriptor::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 FIELD_position:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_anchor:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::Anchor";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::Anchor";
            return nullptr;
        case FIELD_text:
            if (!strcmp(propertyname, "group")) return "text";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_font:
            if (!strcmp(propertyname, "group")) return "text";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_color:
            if (!strcmp(propertyname, "group")) return "text";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_opacity:
            if (!strcmp(propertyname, "group")) return "text";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_halo:
            if (!strcmp(propertyname, "group")) return "text";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cAbstractTextFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cAbstractTextFigure *pp = (cAbstractTextFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cAbstractTextFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cAbstractTextFigure *pp = (cAbstractTextFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cAbstractTextFigureDescriptor::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();
    }
    cAbstractTextFigure *pp = (cAbstractTextFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: return pp->getPosition().str();
        case FIELD_anchor: return enum2string(pp->getAnchor(), "omnetpp::cFigure::Anchor");
        case FIELD_text: return oppstring2string(pp->getText());
        case FIELD_font: return pp->getFont().str();
        case FIELD_color: return pp->getColor().str();
        case FIELD_opacity: return double2string(pp->getOpacity());
        case FIELD_halo: return bool2string(pp->getHalo());
        default: return "";
    }
}

bool cAbstractTextFigureDescriptor::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();
    }
    cAbstractTextFigure *pp = (cAbstractTextFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: pp->setPosition(cFigure::parsePoint(value)); return true;
        case FIELD_anchor: pp->setAnchor((omnetpp::cFigure::Anchor)string2enum(value, "omnetpp::cFigure::Anchor")); return true;
        case FIELD_text: pp->setText((value)); return true;
        case FIELD_font: pp->setFont(cFigure::parseFont(value)); return true;
        case FIELD_color: pp->setColor(cFigure::parseColor(value)); return true;
        case FIELD_opacity: pp->setOpacity(string2double(value)); return true;
        case FIELD_halo: pp->setHalo(string2bool(value)); return true;
        default: return false;
    }
}

const char *cAbstractTextFigureDescriptor::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 *cAbstractTextFigureDescriptor::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();
    }
    cAbstractTextFigure *pp = (cAbstractTextFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: return toVoidPtr(&pp->getPosition()); break;
        case FIELD_font: return toVoidPtr(&pp->getFont()); break;
        case FIELD_color: return toVoidPtr(&pp->getColor()); break;
        default: return nullptr;
    }
}

class cTextFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cTextFigureDescriptor();
    virtual ~cTextFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cTextFigureDescriptor)

cTextFigureDescriptor::cTextFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cTextFigure)), "omnetpp::cAbstractTextFigure")
{
    propertynames = nullptr;
}

cTextFigureDescriptor::~cTextFigureDescriptor()
{
    delete[] propertynames;
}

bool cTextFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cTextFigure *>(obj)!=nullptr;
}

const char **cTextFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cTextFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cTextFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int cTextFigureDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cTextFigureDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cTextFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cTextFigureDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cTextFigureDescriptor::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 *cTextFigureDescriptor::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 cTextFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cTextFigure *pp = (cTextFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cTextFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cTextFigure *pp = (cTextFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cTextFigureDescriptor::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();
    }
    cTextFigure *pp = (cTextFigure *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cTextFigureDescriptor::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();
    }
    cTextFigure *pp = (cTextFigure *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cTextFigureDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cTextFigureDescriptor::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();
    }
    cTextFigure *pp = (cTextFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cLabelFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cLabelFigureDescriptor();
    virtual ~cLabelFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cLabelFigureDescriptor)

cLabelFigureDescriptor::cLabelFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cLabelFigure)), "omnetpp::cAbstractTextFigure")
{
    propertynames = nullptr;
}

cLabelFigureDescriptor::~cLabelFigureDescriptor()
{
    delete[] propertynames;
}

bool cLabelFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cLabelFigure *>(obj)!=nullptr;
}

const char **cLabelFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cLabelFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cLabelFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int cLabelFigureDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cLabelFigureDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cLabelFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cLabelFigureDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cLabelFigureDescriptor::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 *cLabelFigureDescriptor::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 cLabelFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cLabelFigure *pp = (cLabelFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cLabelFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cLabelFigure *pp = (cLabelFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cLabelFigureDescriptor::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();
    }
    cLabelFigure *pp = (cLabelFigure *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cLabelFigureDescriptor::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();
    }
    cLabelFigure *pp = (cLabelFigure *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cLabelFigureDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cLabelFigureDescriptor::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();
    }
    cLabelFigure *pp = (cLabelFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cAbstractImageFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_position,
        FIELD_anchor,
        FIELD_width,
        FIELD_height,
        FIELD_interpolation,
        FIELD_opacity,
        FIELD_tintColor,
        FIELD_tintAmount,
    };
  public:
    cAbstractImageFigureDescriptor();
    virtual ~cAbstractImageFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cAbstractImageFigureDescriptor)

cAbstractImageFigureDescriptor::cAbstractImageFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cAbstractImageFigure)), "omnetpp::cFigure")
{
    propertynames = nullptr;
}

cAbstractImageFigureDescriptor::~cAbstractImageFigureDescriptor()
{
    delete[] propertynames;
}

bool cAbstractImageFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cAbstractImageFigure *>(obj)!=nullptr;
}

const char **cAbstractImageFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cAbstractImageFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cAbstractImageFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 8+basedesc->getFieldCount() : 8;
}

unsigned int cAbstractImageFigureDescriptor::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,    // FIELD_position
        FD_ISEDITABLE,    // FIELD_anchor
        FD_ISEDITABLE,    // FIELD_width
        FD_ISEDITABLE,    // FIELD_height
        FD_ISEDITABLE,    // FIELD_interpolation
        FD_ISEDITABLE,    // FIELD_opacity
        FD_ISEDITABLE,    // FIELD_tintColor
        FD_ISEDITABLE,    // FIELD_tintAmount
    };
    return (field >= 0 && field < 8) ? fieldTypeFlags[field] : 0;
}

const char *cAbstractImageFigureDescriptor::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[] = {
        "position",
        "anchor",
        "width",
        "height",
        "interpolation",
        "opacity",
        "tintColor",
        "tintAmount",
    };
    return (field >= 0 && field < 8) ? fieldNames[field] : nullptr;
}

int cAbstractImageFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'p' && strcmp(fieldName, "position") == 0) return base+0;
    if (fieldName[0] == 'a' && strcmp(fieldName, "anchor") == 0) return base+1;
    if (fieldName[0] == 'w' && strcmp(fieldName, "width") == 0) return base+2;
    if (fieldName[0] == 'h' && strcmp(fieldName, "height") == 0) return base+3;
    if (fieldName[0] == 'i' && strcmp(fieldName, "interpolation") == 0) return base+4;
    if (fieldName[0] == 'o' && strcmp(fieldName, "opacity") == 0) return base+5;
    if (fieldName[0] == 't' && strcmp(fieldName, "tintColor") == 0) return base+6;
    if (fieldName[0] == 't' && strcmp(fieldName, "tintAmount") == 0) return base+7;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cAbstractImageFigureDescriptor::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[] = {
        "omnetpp::cFigure::Point",    // FIELD_position
        "int",    // FIELD_anchor
        "double",    // FIELD_width
        "double",    // FIELD_height
        "int",    // FIELD_interpolation
        "double",    // FIELD_opacity
        "omnetpp::cFigure::Color",    // FIELD_tintColor
        "double",    // FIELD_tintAmount
    };
    return (field >= 0 && field < 8) ? fieldTypeStrings[field] : nullptr;
}

const char **cAbstractImageFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_position: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_anchor: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_width: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_height: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_interpolation: {
            static const char *names[] = { "group", "editable", "enum", "enum",  nullptr };
            return names;
        }
        case FIELD_opacity: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_tintColor: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        case FIELD_tintAmount: {
            static const char *names[] = { "group", "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cAbstractImageFigureDescriptor::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 FIELD_position:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_anchor:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::Anchor";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::Anchor";
            return nullptr;
        case FIELD_width:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_height:
            if (!strcmp(propertyname, "group")) return "geometry";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_interpolation:
            if (!strcmp(propertyname, "group")) return "image";
            if (!strcmp(propertyname, "editable")) return "";
            if (!strcmp(propertyname, "enum")) return "cFigure::Interpolation";
            if (!strcmp(propertyname, "enum")) return "omnetpp::cFigure::Interpolation";
            return nullptr;
        case FIELD_opacity:
            if (!strcmp(propertyname, "group")) return "image";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_tintColor:
            if (!strcmp(propertyname, "group")) return "image";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        case FIELD_tintAmount:
            if (!strcmp(propertyname, "group")) return "image";
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cAbstractImageFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cAbstractImageFigure *pp = (cAbstractImageFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cAbstractImageFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cAbstractImageFigure *pp = (cAbstractImageFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cAbstractImageFigureDescriptor::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();
    }
    cAbstractImageFigure *pp = (cAbstractImageFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: return pp->getPosition().str();
        case FIELD_anchor: return enum2string(pp->getAnchor(), "omnetpp::cFigure::Anchor");
        case FIELD_width: return double2string(pp->getWidth());
        case FIELD_height: return double2string(pp->getHeight());
        case FIELD_interpolation: return enum2string(pp->getInterpolation(), "omnetpp::cFigure::Interpolation");
        case FIELD_opacity: return double2string(pp->getOpacity());
        case FIELD_tintColor: return pp->getTintColor().str();
        case FIELD_tintAmount: return double2string(pp->getTintAmount());
        default: return "";
    }
}

bool cAbstractImageFigureDescriptor::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();
    }
    cAbstractImageFigure *pp = (cAbstractImageFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: pp->setPosition(cFigure::parsePoint(value)); return true;
        case FIELD_anchor: pp->setAnchor((omnetpp::cFigure::Anchor)string2enum(value, "omnetpp::cFigure::Anchor")); return true;
        case FIELD_width: pp->setWidth(string2double(value)); return true;
        case FIELD_height: pp->setHeight(string2double(value)); return true;
        case FIELD_interpolation: pp->setInterpolation((omnetpp::cFigure::Interpolation)string2enum(value, "omnetpp::cFigure::Interpolation")); return true;
        case FIELD_opacity: pp->setOpacity(string2double(value)); return true;
        case FIELD_tintColor: pp->setTintColor(cFigure::parseColor(value)); return true;
        case FIELD_tintAmount: pp->setTintAmount(string2double(value)); return true;
        default: return false;
    }
}

const char *cAbstractImageFigureDescriptor::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 *cAbstractImageFigureDescriptor::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();
    }
    cAbstractImageFigure *pp = (cAbstractImageFigure *)object; (void)pp;
    switch (field) {
        case FIELD_position: return toVoidPtr(&pp->getPosition()); break;
        case FIELD_tintColor: return toVoidPtr(&pp->getTintColor()); break;
        default: return nullptr;
    }
}

class cImageFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_imageName,
    };
  public:
    cImageFigureDescriptor();
    virtual ~cImageFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cImageFigureDescriptor)

cImageFigureDescriptor::cImageFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cImageFigure)), "omnetpp::cAbstractImageFigure")
{
    propertynames = nullptr;
}

cImageFigureDescriptor::~cImageFigureDescriptor()
{
    delete[] propertynames;
}

bool cImageFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cImageFigure *>(obj)!=nullptr;
}

const char **cImageFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cImageFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cImageFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int cImageFigureDescriptor::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,    // FIELD_imageName
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *cImageFigureDescriptor::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[] = {
        "imageName",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int cImageFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'i' && strcmp(fieldName, "imageName") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cImageFigureDescriptor::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",    // FIELD_imageName
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **cImageFigureDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_imageName: {
            static const char *names[] = { "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cImageFigureDescriptor::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 FIELD_imageName:
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cImageFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cImageFigure *pp = (cImageFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cImageFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cImageFigure *pp = (cImageFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cImageFigureDescriptor::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();
    }
    cImageFigure *pp = (cImageFigure *)object; (void)pp;
    switch (field) {
        case FIELD_imageName: return oppstring2string(pp->getImageName());
        default: return "";
    }
}

bool cImageFigureDescriptor::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();
    }
    cImageFigure *pp = (cImageFigure *)object; (void)pp;
    switch (field) {
        case FIELD_imageName: pp->setImageName((value)); return true;
        default: return false;
    }
}

const char *cImageFigureDescriptor::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 *cImageFigureDescriptor::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();
    }
    cImageFigure *pp = (cImageFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cIconFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cIconFigureDescriptor();
    virtual ~cIconFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cIconFigureDescriptor)

cIconFigureDescriptor::cIconFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cIconFigure)), "omnetpp::cImageFigure")
{
    propertynames = nullptr;
}

cIconFigureDescriptor::~cIconFigureDescriptor()
{
    delete[] propertynames;
}

bool cIconFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cIconFigure *>(obj)!=nullptr;
}

const char **cIconFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cIconFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cIconFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int cIconFigureDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cIconFigureDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cIconFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cIconFigureDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cIconFigureDescriptor::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 *cIconFigureDescriptor::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 cIconFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cIconFigure *pp = (cIconFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cIconFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cIconFigure *pp = (cIconFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cIconFigureDescriptor::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();
    }
    cIconFigure *pp = (cIconFigure *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cIconFigureDescriptor::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();
    }
    cIconFigure *pp = (cIconFigure *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cIconFigureDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cIconFigureDescriptor::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();
    }
    cIconFigure *pp = (cIconFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cPixmapFigureDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_pixmap,
    };
  public:
    cPixmapFigureDescriptor();
    virtual ~cPixmapFigureDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cPixmapFigureDescriptor)

cPixmapFigureDescriptor::cPixmapFigureDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cPixmapFigure)), "omnetpp::cAbstractImageFigure")
{
    propertynames = nullptr;
}

cPixmapFigureDescriptor::~cPixmapFigureDescriptor()
{
    delete[] propertynames;
}

bool cPixmapFigureDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cPixmapFigure *>(obj)!=nullptr;
}

const char **cPixmapFigureDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cPixmapFigureDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cPixmapFigureDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int cPixmapFigureDescriptor::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[] = {
        0,    // FIELD_pixmap
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *cPixmapFigureDescriptor::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[] = {
        "pixmap",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int cPixmapFigureDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'p' && strcmp(fieldName, "pixmap") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cPixmapFigureDescriptor::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[] = {
        "omnetpp::cFigure::Pixmap",    // FIELD_pixmap
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **cPixmapFigureDescriptor::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 *cPixmapFigureDescriptor::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 cPixmapFigureDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cPixmapFigure *pp = (cPixmapFigure *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cPixmapFigureDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cPixmapFigure *pp = (cPixmapFigure *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cPixmapFigureDescriptor::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();
    }
    cPixmapFigure *pp = (cPixmapFigure *)object; (void)pp;
    switch (field) {
        case FIELD_pixmap: {std::stringstream out; out << pp->getPixmap(); return out.str();}
        default: return "";
    }
}

bool cPixmapFigureDescriptor::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();
    }
    cPixmapFigure *pp = (cPixmapFigure *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cPixmapFigureDescriptor::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 *cPixmapFigureDescriptor::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();
    }
    cPixmapFigure *pp = (cPixmapFigure *)object; (void)pp;
    switch (field) {
        case FIELD_pixmap: return toVoidPtr(&pp->getPixmap()); break;
        default: return nullptr;
    }
}

class cCanvasDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_rootFigure,
        FIELD_allTags,
        FIELD_backgroundColor,
    };
  public:
    cCanvasDescriptor();
    virtual ~cCanvasDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cCanvasDescriptor)

cCanvasDescriptor::cCanvasDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cCanvas)), "omnetpp::cOwnedObject")
{
    propertynames = nullptr;
}

cCanvasDescriptor::~cCanvasDescriptor()
{
    delete[] propertynames;
}

bool cCanvasDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cCanvas *>(obj)!=nullptr;
}

const char **cCanvasDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cCanvasDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cCanvasDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int cCanvasDescriptor::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_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_rootFigure
        0,    // FIELD_allTags
        FD_ISEDITABLE,    // FIELD_backgroundColor
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *cCanvasDescriptor::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[] = {
        "rootFigure",
        "allTags",
        "backgroundColor",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int cCanvasDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'r' && strcmp(fieldName, "rootFigure") == 0) return base+0;
    if (fieldName[0] == 'a' && strcmp(fieldName, "allTags") == 0) return base+1;
    if (fieldName[0] == 'b' && strcmp(fieldName, "backgroundColor") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cCanvasDescriptor::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[] = {
        "omnetpp::cFigure",    // FIELD_rootFigure
        "string",    // FIELD_allTags
        "omnetpp::cFigure::Color",    // FIELD_backgroundColor
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **cCanvasDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_backgroundColor: {
            static const char *names[] = { "editable",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cCanvasDescriptor::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 FIELD_backgroundColor:
            if (!strcmp(propertyname, "editable")) return "";
            return nullptr;
        default: return nullptr;
    }
}

int cCanvasDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cCanvas *pp = (cCanvas *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cCanvasDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cCanvas *pp = (cCanvas *)object; (void)pp;
    switch (field) {
        case FIELD_rootFigure: { const cFigure * value = pp->getRootFigure(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cCanvasDescriptor::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();
    }
    cCanvas *pp = (cCanvas *)object; (void)pp;
    switch (field) {
        case FIELD_rootFigure: {std::stringstream out; out << pp->getRootFigure(); return out.str();}
        case FIELD_allTags: return oppstring2string(pp->getAllTags());
        case FIELD_backgroundColor: return pp->getBackgroundColor().str();
        default: return "";
    }
}

bool cCanvasDescriptor::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();
    }
    cCanvas *pp = (cCanvas *)object; (void)pp;
    switch (field) {
        case FIELD_backgroundColor: pp->setBackgroundColor(cFigure::parseColor(value)); return true;
        default: return false;
    }
}

const char *cCanvasDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_rootFigure: return omnetpp::opp_typename(typeid(cFigure));
        default: return nullptr;
    };
}

void *cCanvasDescriptor::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();
    }
    cCanvas *pp = (cCanvas *)object; (void)pp;
    switch (field) {
        case FIELD_rootFigure: return toVoidPtr(pp->getRootFigure()); break;
        case FIELD_backgroundColor: return toVoidPtr(&pp->getBackgroundColor()); break;
        default: return nullptr;
    }
}

class cResultListenerDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cResultListenerDescriptor();
    virtual ~cResultListenerDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cResultListenerDescriptor)

cResultListenerDescriptor::cResultListenerDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cResultListener)), "omnetpp::cIListener")
{
    propertynames = nullptr;
}

cResultListenerDescriptor::~cResultListenerDescriptor()
{
    delete[] propertynames;
}

bool cResultListenerDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cResultListener *>(obj)!=nullptr;
}

const char **cResultListenerDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cResultListenerDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cResultListenerDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int cResultListenerDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cResultListenerDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cResultListenerDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cResultListenerDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cResultListenerDescriptor::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 *cResultListenerDescriptor::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 cResultListenerDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cResultListener *pp = (cResultListener *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cResultListenerDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cResultListener *pp = (cResultListener *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cResultListenerDescriptor::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();
    }
    cResultListener *pp = (cResultListener *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cResultListenerDescriptor::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();
    }
    cResultListener *pp = (cResultListener *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cResultListenerDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cResultListenerDescriptor::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();
    }
    cResultListener *pp = (cResultListener *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cResultFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_delegates,
    };
  public:
    cResultFilterDescriptor();
    virtual ~cResultFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cResultFilterDescriptor)

cResultFilterDescriptor::cResultFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cResultFilter)), "omnetpp::cResultListener")
{
    propertynames = nullptr;
}

cResultFilterDescriptor::~cResultFilterDescriptor()
{
    delete[] propertynames;
}

bool cResultFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cResultFilter *>(obj)!=nullptr;
}

const char **cResultFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cResultFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cResultFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int cResultFilterDescriptor::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_ISARRAY | FD_ISCOMPOUND | FD_ISPOINTER,    // FIELD_delegates
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *cResultFilterDescriptor::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[] = {
        "delegates",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int cResultFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'd' && strcmp(fieldName, "delegates") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cResultFilterDescriptor::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[] = {
        "omnetpp::cResultListener",    // FIELD_delegates
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **cResultFilterDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_delegates: {
            static const char *names[] = { "sizeGetter", "getter", "toString",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *cResultFilterDescriptor::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 FIELD_delegates:
            if (!strcmp(propertyname, "sizeGetter")) return "getNumDelegates";
            if (!strcmp(propertyname, "getter")) return "getDelegate";
            if (!strcmp(propertyname, "toString")) return "->str()";
            return nullptr;
        default: return nullptr;
    }
}

int cResultFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cResultFilter *pp = (cResultFilter *)object; (void)pp;
    switch (field) {
        case FIELD_delegates: return pp->getNumDelegates();
        default: return 0;
    }
}

const char *cResultFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cResultFilter *pp = (cResultFilter *)object; (void)pp;
    switch (field) {
        case FIELD_delegates: { const cResultListener * value = pp->getDelegate(i); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cResultFilterDescriptor::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();
    }
    cResultFilter *pp = (cResultFilter *)object; (void)pp;
    switch (field) {
        case FIELD_delegates: return pp->getDelegate(i)->str();
        default: return "";
    }
}

bool cResultFilterDescriptor::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();
    }
    cResultFilter *pp = (cResultFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cResultFilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_delegates: return omnetpp::opp_typename(typeid(cResultListener));
        default: return nullptr;
    };
}

void *cResultFilterDescriptor::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();
    }
    cResultFilter *pp = (cResultFilter *)object; (void)pp;
    switch (field) {
        case FIELD_delegates: return toVoidPtr(pp->getDelegate(i)); break;
        default: return nullptr;
    }
}

class WarmupPeriodFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_endWarmupPeriod,
    };
  public:
    WarmupPeriodFilterDescriptor();
    virtual ~WarmupPeriodFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(WarmupPeriodFilterDescriptor)

WarmupPeriodFilterDescriptor::WarmupPeriodFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::WarmupPeriodFilter)), "omnetpp::cResultFilter")
{
    propertynames = nullptr;
}

WarmupPeriodFilterDescriptor::~WarmupPeriodFilterDescriptor()
{
    delete[] propertynames;
}

bool WarmupPeriodFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<WarmupPeriodFilter *>(obj)!=nullptr;
}

const char **WarmupPeriodFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *WarmupPeriodFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int WarmupPeriodFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int WarmupPeriodFilterDescriptor::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[] = {
        0,    // FIELD_endWarmupPeriod
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *WarmupPeriodFilterDescriptor::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[] = {
        "endWarmupPeriod",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int WarmupPeriodFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'e' && strcmp(fieldName, "endWarmupPeriod") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *WarmupPeriodFilterDescriptor::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[] = {
        "omnetpp::simtime_t",    // FIELD_endWarmupPeriod
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **WarmupPeriodFilterDescriptor::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 *WarmupPeriodFilterDescriptor::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 WarmupPeriodFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    WarmupPeriodFilter *pp = (WarmupPeriodFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *WarmupPeriodFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    WarmupPeriodFilter *pp = (WarmupPeriodFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string WarmupPeriodFilterDescriptor::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();
    }
    WarmupPeriodFilter *pp = (WarmupPeriodFilter *)object; (void)pp;
    switch (field) {
        case FIELD_endWarmupPeriod: return simtime2string(pp->getEndWarmupPeriod());
        default: return "";
    }
}

bool WarmupPeriodFilterDescriptor::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();
    }
    WarmupPeriodFilter *pp = (WarmupPeriodFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *WarmupPeriodFilterDescriptor::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 *WarmupPeriodFilterDescriptor::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();
    }
    WarmupPeriodFilter *pp = (WarmupPeriodFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class CountFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_count,
    };
  public:
    CountFilterDescriptor();
    virtual ~CountFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(CountFilterDescriptor)

CountFilterDescriptor::CountFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::CountFilter)), "omnetpp::cResultFilter")
{
    propertynames = nullptr;
}

CountFilterDescriptor::~CountFilterDescriptor()
{
    delete[] propertynames;
}

bool CountFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<CountFilter *>(obj)!=nullptr;
}

const char **CountFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *CountFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int CountFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int CountFilterDescriptor::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[] = {
        0,    // FIELD_count
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *CountFilterDescriptor::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[] = {
        "count",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int CountFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "count") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CountFilterDescriptor::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[] = {
        "long",    // FIELD_count
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **CountFilterDescriptor::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 *CountFilterDescriptor::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 CountFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    CountFilter *pp = (CountFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *CountFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    CountFilter *pp = (CountFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string CountFilterDescriptor::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();
    }
    CountFilter *pp = (CountFilter *)object; (void)pp;
    switch (field) {
        case FIELD_count: return long2string(pp->getCount());
        default: return "";
    }
}

bool CountFilterDescriptor::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();
    }
    CountFilter *pp = (CountFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *CountFilterDescriptor::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 *CountFilterDescriptor::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();
    }
    CountFilter *pp = (CountFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class ConstantFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_constant,
    };
  public:
    ConstantFilterDescriptor();
    virtual ~ConstantFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(ConstantFilterDescriptor)

ConstantFilterDescriptor::ConstantFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::ConstantFilter)), "omnetpp::cResultFilter")
{
    propertynames = nullptr;
}

ConstantFilterDescriptor::~ConstantFilterDescriptor()
{
    delete[] propertynames;
}

bool ConstantFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<ConstantFilter *>(obj)!=nullptr;
}

const char **ConstantFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *ConstantFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int ConstantFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int ConstantFilterDescriptor::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[] = {
        0,    // FIELD_constant
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *ConstantFilterDescriptor::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[] = {
        "constant",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int ConstantFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "constant") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *ConstantFilterDescriptor::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[] = {
        "double",    // FIELD_constant
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **ConstantFilterDescriptor::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 *ConstantFilterDescriptor::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 ConstantFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    ConstantFilter *pp = (ConstantFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *ConstantFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    ConstantFilter *pp = (ConstantFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string ConstantFilterDescriptor::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();
    }
    ConstantFilter *pp = (ConstantFilter *)object; (void)pp;
    switch (field) {
        case FIELD_constant: return double2string(pp->getConstant());
        default: return "";
    }
}

bool ConstantFilterDescriptor::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();
    }
    ConstantFilter *pp = (ConstantFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *ConstantFilterDescriptor::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 *ConstantFilterDescriptor::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();
    }
    ConstantFilter *pp = (ConstantFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class Constant0FilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    Constant0FilterDescriptor();
    virtual ~Constant0FilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(Constant0FilterDescriptor)

Constant0FilterDescriptor::Constant0FilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::Constant0Filter)), "omnetpp::ConstantFilter")
{
    propertynames = nullptr;
}

Constant0FilterDescriptor::~Constant0FilterDescriptor()
{
    delete[] propertynames;
}

bool Constant0FilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<Constant0Filter *>(obj)!=nullptr;
}

const char **Constant0FilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *Constant0FilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int Constant0FilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int Constant0FilterDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *Constant0FilterDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int Constant0FilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *Constant0FilterDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **Constant0FilterDescriptor::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 *Constant0FilterDescriptor::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 Constant0FilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    Constant0Filter *pp = (Constant0Filter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *Constant0FilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    Constant0Filter *pp = (Constant0Filter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string Constant0FilterDescriptor::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();
    }
    Constant0Filter *pp = (Constant0Filter *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool Constant0FilterDescriptor::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();
    }
    Constant0Filter *pp = (Constant0Filter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *Constant0FilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *Constant0FilterDescriptor::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();
    }
    Constant0Filter *pp = (Constant0Filter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class Constant1FilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    Constant1FilterDescriptor();
    virtual ~Constant1FilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(Constant1FilterDescriptor)

Constant1FilterDescriptor::Constant1FilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::Constant1Filter)), "omnetpp::ConstantFilter")
{
    propertynames = nullptr;
}

Constant1FilterDescriptor::~Constant1FilterDescriptor()
{
    delete[] propertynames;
}

bool Constant1FilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<Constant1Filter *>(obj)!=nullptr;
}

const char **Constant1FilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *Constant1FilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int Constant1FilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int Constant1FilterDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *Constant1FilterDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int Constant1FilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *Constant1FilterDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **Constant1FilterDescriptor::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 *Constant1FilterDescriptor::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 Constant1FilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    Constant1Filter *pp = (Constant1Filter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *Constant1FilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    Constant1Filter *pp = (Constant1Filter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string Constant1FilterDescriptor::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();
    }
    Constant1Filter *pp = (Constant1Filter *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool Constant1FilterDescriptor::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();
    }
    Constant1Filter *pp = (Constant1Filter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *Constant1FilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *Constant1FilterDescriptor::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();
    }
    Constant1Filter *pp = (Constant1Filter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cNumericResultFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cNumericResultFilterDescriptor();
    virtual ~cNumericResultFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cNumericResultFilterDescriptor)

cNumericResultFilterDescriptor::cNumericResultFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cNumericResultFilter)), "omnetpp::cResultFilter")
{
    propertynames = nullptr;
}

cNumericResultFilterDescriptor::~cNumericResultFilterDescriptor()
{
    delete[] propertynames;
}

bool cNumericResultFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cNumericResultFilter *>(obj)!=nullptr;
}

const char **cNumericResultFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cNumericResultFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cNumericResultFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int cNumericResultFilterDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cNumericResultFilterDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cNumericResultFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cNumericResultFilterDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cNumericResultFilterDescriptor::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 *cNumericResultFilterDescriptor::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 cNumericResultFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cNumericResultFilter *pp = (cNumericResultFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cNumericResultFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cNumericResultFilter *pp = (cNumericResultFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cNumericResultFilterDescriptor::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();
    }
    cNumericResultFilter *pp = (cNumericResultFilter *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cNumericResultFilterDescriptor::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();
    }
    cNumericResultFilter *pp = (cNumericResultFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cNumericResultFilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cNumericResultFilterDescriptor::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();
    }
    cNumericResultFilter *pp = (cNumericResultFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class IdentityFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    IdentityFilterDescriptor();
    virtual ~IdentityFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(IdentityFilterDescriptor)

IdentityFilterDescriptor::IdentityFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::IdentityFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

IdentityFilterDescriptor::~IdentityFilterDescriptor()
{
    delete[] propertynames;
}

bool IdentityFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<IdentityFilter *>(obj)!=nullptr;
}

const char **IdentityFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *IdentityFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int IdentityFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int IdentityFilterDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *IdentityFilterDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int IdentityFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *IdentityFilterDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **IdentityFilterDescriptor::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 *IdentityFilterDescriptor::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 IdentityFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    IdentityFilter *pp = (IdentityFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *IdentityFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    IdentityFilter *pp = (IdentityFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string IdentityFilterDescriptor::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();
    }
    IdentityFilter *pp = (IdentityFilter *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool IdentityFilterDescriptor::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();
    }
    IdentityFilter *pp = (IdentityFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *IdentityFilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *IdentityFilterDescriptor::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();
    }
    IdentityFilter *pp = (IdentityFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class SumFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_sum,
    };
  public:
    SumFilterDescriptor();
    virtual ~SumFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(SumFilterDescriptor)

SumFilterDescriptor::SumFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::SumFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

SumFilterDescriptor::~SumFilterDescriptor()
{
    delete[] propertynames;
}

bool SumFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<SumFilter *>(obj)!=nullptr;
}

const char **SumFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *SumFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int SumFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int SumFilterDescriptor::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[] = {
        0,    // FIELD_sum
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *SumFilterDescriptor::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[] = {
        "sum",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int SumFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 's' && strcmp(fieldName, "sum") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *SumFilterDescriptor::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[] = {
        "double",    // FIELD_sum
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **SumFilterDescriptor::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 *SumFilterDescriptor::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 SumFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    SumFilter *pp = (SumFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *SumFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    SumFilter *pp = (SumFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string SumFilterDescriptor::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();
    }
    SumFilter *pp = (SumFilter *)object; (void)pp;
    switch (field) {
        case FIELD_sum: return double2string(pp->getSum());
        default: return "";
    }
}

bool SumFilterDescriptor::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();
    }
    SumFilter *pp = (SumFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *SumFilterDescriptor::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 *SumFilterDescriptor::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();
    }
    SumFilter *pp = (SumFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class MeanFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_mean,
    };
  public:
    MeanFilterDescriptor();
    virtual ~MeanFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(MeanFilterDescriptor)

MeanFilterDescriptor::MeanFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::MeanFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

MeanFilterDescriptor::~MeanFilterDescriptor()
{
    delete[] propertynames;
}

bool MeanFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<MeanFilter *>(obj)!=nullptr;
}

const char **MeanFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *MeanFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int MeanFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int MeanFilterDescriptor::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[] = {
        0,    // FIELD_mean
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *MeanFilterDescriptor::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[] = {
        "mean",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int MeanFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'm' && strcmp(fieldName, "mean") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *MeanFilterDescriptor::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[] = {
        "double",    // FIELD_mean
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **MeanFilterDescriptor::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 *MeanFilterDescriptor::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 MeanFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    MeanFilter *pp = (MeanFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *MeanFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    MeanFilter *pp = (MeanFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string MeanFilterDescriptor::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();
    }
    MeanFilter *pp = (MeanFilter *)object; (void)pp;
    switch (field) {
        case FIELD_mean: return double2string(pp->getMean());
        default: return "";
    }
}

bool MeanFilterDescriptor::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();
    }
    MeanFilter *pp = (MeanFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *MeanFilterDescriptor::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 *MeanFilterDescriptor::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();
    }
    MeanFilter *pp = (MeanFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class MinFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_min,
    };
  public:
    MinFilterDescriptor();
    virtual ~MinFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(MinFilterDescriptor)

MinFilterDescriptor::MinFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::MinFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

MinFilterDescriptor::~MinFilterDescriptor()
{
    delete[] propertynames;
}

bool MinFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<MinFilter *>(obj)!=nullptr;
}

const char **MinFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *MinFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int MinFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int MinFilterDescriptor::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[] = {
        0,    // FIELD_min
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *MinFilterDescriptor::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[] = {
        "min",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int MinFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'm' && strcmp(fieldName, "min") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *MinFilterDescriptor::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[] = {
        "double",    // FIELD_min
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **MinFilterDescriptor::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 *MinFilterDescriptor::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 MinFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    MinFilter *pp = (MinFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *MinFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    MinFilter *pp = (MinFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string MinFilterDescriptor::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();
    }
    MinFilter *pp = (MinFilter *)object; (void)pp;
    switch (field) {
        case FIELD_min: return double2string(pp->getMin());
        default: return "";
    }
}

bool MinFilterDescriptor::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();
    }
    MinFilter *pp = (MinFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *MinFilterDescriptor::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 *MinFilterDescriptor::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();
    }
    MinFilter *pp = (MinFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class MaxFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_max,
    };
  public:
    MaxFilterDescriptor();
    virtual ~MaxFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(MaxFilterDescriptor)

MaxFilterDescriptor::MaxFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::MaxFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

MaxFilterDescriptor::~MaxFilterDescriptor()
{
    delete[] propertynames;
}

bool MaxFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<MaxFilter *>(obj)!=nullptr;
}

const char **MaxFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *MaxFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int MaxFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int MaxFilterDescriptor::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[] = {
        0,    // FIELD_max
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *MaxFilterDescriptor::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[] = {
        "max",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int MaxFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'm' && strcmp(fieldName, "max") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *MaxFilterDescriptor::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[] = {
        "double",    // FIELD_max
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **MaxFilterDescriptor::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 *MaxFilterDescriptor::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 MaxFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    MaxFilter *pp = (MaxFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *MaxFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    MaxFilter *pp = (MaxFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string MaxFilterDescriptor::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();
    }
    MaxFilter *pp = (MaxFilter *)object; (void)pp;
    switch (field) {
        case FIELD_max: return double2string(pp->getMax());
        default: return "";
    }
}

bool MaxFilterDescriptor::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();
    }
    MaxFilter *pp = (MaxFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *MaxFilterDescriptor::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 *MaxFilterDescriptor::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();
    }
    MaxFilter *pp = (MaxFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class TimeAverageFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_timeAverage,
    };
  public:
    TimeAverageFilterDescriptor();
    virtual ~TimeAverageFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(TimeAverageFilterDescriptor)

TimeAverageFilterDescriptor::TimeAverageFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::TimeAverageFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

TimeAverageFilterDescriptor::~TimeAverageFilterDescriptor()
{
    delete[] propertynames;
}

bool TimeAverageFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<TimeAverageFilter *>(obj)!=nullptr;
}

const char **TimeAverageFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *TimeAverageFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int TimeAverageFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int TimeAverageFilterDescriptor::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[] = {
        0,    // FIELD_timeAverage
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *TimeAverageFilterDescriptor::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[] = {
        "timeAverage",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int TimeAverageFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 't' && strcmp(fieldName, "timeAverage") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *TimeAverageFilterDescriptor::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[] = {
        "double",    // FIELD_timeAverage
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **TimeAverageFilterDescriptor::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 *TimeAverageFilterDescriptor::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 TimeAverageFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    TimeAverageFilter *pp = (TimeAverageFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *TimeAverageFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    TimeAverageFilter *pp = (TimeAverageFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string TimeAverageFilterDescriptor::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();
    }
    TimeAverageFilter *pp = (TimeAverageFilter *)object; (void)pp;
    switch (field) {
        case FIELD_timeAverage: return double2string(pp->getTimeAverage());
        default: return "";
    }
}

bool TimeAverageFilterDescriptor::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();
    }
    TimeAverageFilter *pp = (TimeAverageFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *TimeAverageFilterDescriptor::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 *TimeAverageFilterDescriptor::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();
    }
    TimeAverageFilter *pp = (TimeAverageFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class RemoveRepeatsFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_lastValue,
    };
  public:
    RemoveRepeatsFilterDescriptor();
    virtual ~RemoveRepeatsFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(RemoveRepeatsFilterDescriptor)

RemoveRepeatsFilterDescriptor::RemoveRepeatsFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::RemoveRepeatsFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

RemoveRepeatsFilterDescriptor::~RemoveRepeatsFilterDescriptor()
{
    delete[] propertynames;
}

bool RemoveRepeatsFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<RemoveRepeatsFilter *>(obj)!=nullptr;
}

const char **RemoveRepeatsFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *RemoveRepeatsFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int RemoveRepeatsFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int RemoveRepeatsFilterDescriptor::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[] = {
        0,    // FIELD_lastValue
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *RemoveRepeatsFilterDescriptor::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[] = {
        "lastValue",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int RemoveRepeatsFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastValue") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *RemoveRepeatsFilterDescriptor::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[] = {
        "double",    // FIELD_lastValue
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **RemoveRepeatsFilterDescriptor::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 *RemoveRepeatsFilterDescriptor::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 RemoveRepeatsFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    RemoveRepeatsFilter *pp = (RemoveRepeatsFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *RemoveRepeatsFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    RemoveRepeatsFilter *pp = (RemoveRepeatsFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string RemoveRepeatsFilterDescriptor::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();
    }
    RemoveRepeatsFilter *pp = (RemoveRepeatsFilter *)object; (void)pp;
    switch (field) {
        case FIELD_lastValue: return double2string(pp->getLastValue());
        default: return "";
    }
}

bool RemoveRepeatsFilterDescriptor::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();
    }
    RemoveRepeatsFilter *pp = (RemoveRepeatsFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *RemoveRepeatsFilterDescriptor::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 *RemoveRepeatsFilterDescriptor::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();
    }
    RemoveRepeatsFilter *pp = (RemoveRepeatsFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class ExpressionFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_expression,
        FIELD_lastValue,
        FIELD_lastTimestamp,
    };
  public:
    ExpressionFilterDescriptor();
    virtual ~ExpressionFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(ExpressionFilterDescriptor)

ExpressionFilterDescriptor::ExpressionFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::ExpressionFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

ExpressionFilterDescriptor::~ExpressionFilterDescriptor()
{
    delete[] propertynames;
}

bool ExpressionFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<ExpressionFilter *>(obj)!=nullptr;
}

const char **ExpressionFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *ExpressionFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int ExpressionFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int ExpressionFilterDescriptor::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[] = {
        0,    // FIELD_expression
        0,    // FIELD_lastValue
        0,    // FIELD_lastTimestamp
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *ExpressionFilterDescriptor::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[] = {
        "expression",
        "lastValue",
        "lastTimestamp",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int ExpressionFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'e' && strcmp(fieldName, "expression") == 0) return base+0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastValue") == 0) return base+1;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastTimestamp") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *ExpressionFilterDescriptor::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",    // FIELD_expression
        "double",    // FIELD_lastValue
        "omnetpp::simtime_t",    // FIELD_lastTimestamp
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **ExpressionFilterDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_expression: {
            static const char *names[] = { "toString",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *ExpressionFilterDescriptor::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 FIELD_expression:
            if (!strcmp(propertyname, "toString")) return ".str()";
            return nullptr;
        default: return nullptr;
    }
}

int ExpressionFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    ExpressionFilter *pp = (ExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *ExpressionFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    ExpressionFilter *pp = (ExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string ExpressionFilterDescriptor::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();
    }
    ExpressionFilter *pp = (ExpressionFilter *)object; (void)pp;
    switch (field) {
        case FIELD_expression: return pp->getExpression().str();
        case FIELD_lastValue: return double2string(pp->getLastValue());
        case FIELD_lastTimestamp: return simtime2string(pp->getLastTimestamp());
        default: return "";
    }
}

bool ExpressionFilterDescriptor::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();
    }
    ExpressionFilter *pp = (ExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *ExpressionFilterDescriptor::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 *ExpressionFilterDescriptor::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();
    }
    ExpressionFilter *pp = (ExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class UnaryExpressionFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_lastInputValue,
    };
  public:
    UnaryExpressionFilterDescriptor();
    virtual ~UnaryExpressionFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(UnaryExpressionFilterDescriptor)

UnaryExpressionFilterDescriptor::UnaryExpressionFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::UnaryExpressionFilter)), "omnetpp::ExpressionFilter")
{
    propertynames = nullptr;
}

UnaryExpressionFilterDescriptor::~UnaryExpressionFilterDescriptor()
{
    delete[] propertynames;
}

bool UnaryExpressionFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<UnaryExpressionFilter *>(obj)!=nullptr;
}

const char **UnaryExpressionFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *UnaryExpressionFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int UnaryExpressionFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int UnaryExpressionFilterDescriptor::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[] = {
        0,    // FIELD_lastInputValue
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *UnaryExpressionFilterDescriptor::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[] = {
        "lastInputValue",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int UnaryExpressionFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastInputValue") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *UnaryExpressionFilterDescriptor::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[] = {
        "double",    // FIELD_lastInputValue
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **UnaryExpressionFilterDescriptor::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 *UnaryExpressionFilterDescriptor::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 UnaryExpressionFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    UnaryExpressionFilter *pp = (UnaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *UnaryExpressionFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    UnaryExpressionFilter *pp = (UnaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string UnaryExpressionFilterDescriptor::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();
    }
    UnaryExpressionFilter *pp = (UnaryExpressionFilter *)object; (void)pp;
    switch (field) {
        case FIELD_lastInputValue: return double2string(pp->getLastInputValue());
        default: return "";
    }
}

bool UnaryExpressionFilterDescriptor::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();
    }
    UnaryExpressionFilter *pp = (UnaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *UnaryExpressionFilterDescriptor::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 *UnaryExpressionFilterDescriptor::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();
    }
    UnaryExpressionFilter *pp = (UnaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class NaryExpressionFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    NaryExpressionFilterDescriptor();
    virtual ~NaryExpressionFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(NaryExpressionFilterDescriptor)

NaryExpressionFilterDescriptor::NaryExpressionFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::NaryExpressionFilter)), "omnetpp::ExpressionFilter")
{
    propertynames = nullptr;
}

NaryExpressionFilterDescriptor::~NaryExpressionFilterDescriptor()
{
    delete[] propertynames;
}

bool NaryExpressionFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<NaryExpressionFilter *>(obj)!=nullptr;
}

const char **NaryExpressionFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *NaryExpressionFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int NaryExpressionFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int NaryExpressionFilterDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *NaryExpressionFilterDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int NaryExpressionFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *NaryExpressionFilterDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **NaryExpressionFilterDescriptor::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 *NaryExpressionFilterDescriptor::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 NaryExpressionFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    NaryExpressionFilter *pp = (NaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *NaryExpressionFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    NaryExpressionFilter *pp = (NaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string NaryExpressionFilterDescriptor::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();
    }
    NaryExpressionFilter *pp = (NaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool NaryExpressionFilterDescriptor::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();
    }
    NaryExpressionFilter *pp = (NaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *NaryExpressionFilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *NaryExpressionFilterDescriptor::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();
    }
    NaryExpressionFilter *pp = (NaryExpressionFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cObjectResultFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cObjectResultFilterDescriptor();
    virtual ~cObjectResultFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cObjectResultFilterDescriptor)

cObjectResultFilterDescriptor::cObjectResultFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cObjectResultFilter)), "omnetpp::cResultFilter")
{
    propertynames = nullptr;
}

cObjectResultFilterDescriptor::~cObjectResultFilterDescriptor()
{
    delete[] propertynames;
}

bool cObjectResultFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cObjectResultFilter *>(obj)!=nullptr;
}

const char **cObjectResultFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cObjectResultFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cObjectResultFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int cObjectResultFilterDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cObjectResultFilterDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cObjectResultFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cObjectResultFilterDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cObjectResultFilterDescriptor::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 *cObjectResultFilterDescriptor::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 cObjectResultFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cObjectResultFilter *pp = (cObjectResultFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cObjectResultFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cObjectResultFilter *pp = (cObjectResultFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cObjectResultFilterDescriptor::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();
    }
    cObjectResultFilter *pp = (cObjectResultFilter *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cObjectResultFilterDescriptor::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();
    }
    cObjectResultFilter *pp = (cObjectResultFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cObjectResultFilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cObjectResultFilterDescriptor::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();
    }
    cObjectResultFilter *pp = (cObjectResultFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class PacketBytesFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    PacketBytesFilterDescriptor();
    virtual ~PacketBytesFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(PacketBytesFilterDescriptor)

PacketBytesFilterDescriptor::PacketBytesFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::PacketBytesFilter)), "omnetpp::cObjectResultFilter")
{
    propertynames = nullptr;
}

PacketBytesFilterDescriptor::~PacketBytesFilterDescriptor()
{
    delete[] propertynames;
}

bool PacketBytesFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<PacketBytesFilter *>(obj)!=nullptr;
}

const char **PacketBytesFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *PacketBytesFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int PacketBytesFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int PacketBytesFilterDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *PacketBytesFilterDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int PacketBytesFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *PacketBytesFilterDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **PacketBytesFilterDescriptor::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 *PacketBytesFilterDescriptor::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 PacketBytesFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    PacketBytesFilter *pp = (PacketBytesFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *PacketBytesFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    PacketBytesFilter *pp = (PacketBytesFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string PacketBytesFilterDescriptor::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();
    }
    PacketBytesFilter *pp = (PacketBytesFilter *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool PacketBytesFilterDescriptor::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();
    }
    PacketBytesFilter *pp = (PacketBytesFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *PacketBytesFilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *PacketBytesFilterDescriptor::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();
    }
    PacketBytesFilter *pp = (PacketBytesFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class PacketBitsFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    PacketBitsFilterDescriptor();
    virtual ~PacketBitsFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(PacketBitsFilterDescriptor)

PacketBitsFilterDescriptor::PacketBitsFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::PacketBitsFilter)), "omnetpp::cObjectResultFilter")
{
    propertynames = nullptr;
}

PacketBitsFilterDescriptor::~PacketBitsFilterDescriptor()
{
    delete[] propertynames;
}

bool PacketBitsFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<PacketBitsFilter *>(obj)!=nullptr;
}

const char **PacketBitsFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *PacketBitsFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int PacketBitsFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int PacketBitsFilterDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *PacketBitsFilterDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int PacketBitsFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *PacketBitsFilterDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **PacketBitsFilterDescriptor::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 *PacketBitsFilterDescriptor::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 PacketBitsFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    PacketBitsFilter *pp = (PacketBitsFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *PacketBitsFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    PacketBitsFilter *pp = (PacketBitsFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string PacketBitsFilterDescriptor::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();
    }
    PacketBitsFilter *pp = (PacketBitsFilter *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool PacketBitsFilterDescriptor::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();
    }
    PacketBitsFilter *pp = (PacketBitsFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *PacketBitsFilterDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *PacketBitsFilterDescriptor::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();
    }
    PacketBitsFilter *pp = (PacketBitsFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class SumPerDurationFilterDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_sumPerDuration,
    };
  public:
    SumPerDurationFilterDescriptor();
    virtual ~SumPerDurationFilterDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(SumPerDurationFilterDescriptor)

SumPerDurationFilterDescriptor::SumPerDurationFilterDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::SumPerDurationFilter)), "omnetpp::cNumericResultFilter")
{
    propertynames = nullptr;
}

SumPerDurationFilterDescriptor::~SumPerDurationFilterDescriptor()
{
    delete[] propertynames;
}

bool SumPerDurationFilterDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<SumPerDurationFilter *>(obj)!=nullptr;
}

const char **SumPerDurationFilterDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *SumPerDurationFilterDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int SumPerDurationFilterDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int SumPerDurationFilterDescriptor::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[] = {
        0,    // FIELD_sumPerDuration
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *SumPerDurationFilterDescriptor::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[] = {
        "sumPerDuration",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int SumPerDurationFilterDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 's' && strcmp(fieldName, "sumPerDuration") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *SumPerDurationFilterDescriptor::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[] = {
        "double",    // FIELD_sumPerDuration
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **SumPerDurationFilterDescriptor::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 *SumPerDurationFilterDescriptor::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 SumPerDurationFilterDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    SumPerDurationFilter *pp = (SumPerDurationFilter *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *SumPerDurationFilterDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    SumPerDurationFilter *pp = (SumPerDurationFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string SumPerDurationFilterDescriptor::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();
    }
    SumPerDurationFilter *pp = (SumPerDurationFilter *)object; (void)pp;
    switch (field) {
        case FIELD_sumPerDuration: return double2string(pp->getSumPerDuration());
        default: return "";
    }
}

bool SumPerDurationFilterDescriptor::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();
    }
    SumPerDurationFilter *pp = (SumPerDurationFilter *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *SumPerDurationFilterDescriptor::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 *SumPerDurationFilterDescriptor::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();
    }
    SumPerDurationFilter *pp = (SumPerDurationFilter *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class cResultRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_component,
        FIELD_resultName,
        FIELD_statisticName,
        FIELD_recordingMode,
    };
  public:
    cResultRecorderDescriptor();
    virtual ~cResultRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cResultRecorderDescriptor)

cResultRecorderDescriptor::cResultRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cResultRecorder)), "omnetpp::cResultListener")
{
    propertynames = nullptr;
}

cResultRecorderDescriptor::~cResultRecorderDescriptor()
{
    delete[] propertynames;
}

bool cResultRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cResultRecorder *>(obj)!=nullptr;
}

const char **cResultRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cResultRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cResultRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 4+basedesc->getFieldCount() : 4;
}

unsigned int cResultRecorderDescriptor::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_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_component
        0,    // FIELD_resultName
        0,    // FIELD_statisticName
        0,    // FIELD_recordingMode
    };
    return (field >= 0 && field < 4) ? fieldTypeFlags[field] : 0;
}

const char *cResultRecorderDescriptor::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[] = {
        "component",
        "resultName",
        "statisticName",
        "recordingMode",
    };
    return (field >= 0 && field < 4) ? fieldNames[field] : nullptr;
}

int cResultRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "component") == 0) return base+0;
    if (fieldName[0] == 'r' && strcmp(fieldName, "resultName") == 0) return base+1;
    if (fieldName[0] == 's' && strcmp(fieldName, "statisticName") == 0) return base+2;
    if (fieldName[0] == 'r' && strcmp(fieldName, "recordingMode") == 0) return base+3;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cResultRecorderDescriptor::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[] = {
        "omnetpp::cComponent",    // FIELD_component
        "string",    // FIELD_resultName
        "string",    // FIELD_statisticName
        "string",    // FIELD_recordingMode
    };
    return (field >= 0 && field < 4) ? fieldTypeStrings[field] : nullptr;
}

const char **cResultRecorderDescriptor::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 *cResultRecorderDescriptor::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 cResultRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cResultRecorder *pp = (cResultRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cResultRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cResultRecorder *pp = (cResultRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_component: { const cComponent * value = pp->getComponent(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string cResultRecorderDescriptor::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();
    }
    cResultRecorder *pp = (cResultRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_component: {std::stringstream out; out << pp->getComponent(); return out.str();}
        case FIELD_resultName: return oppstring2string(pp->getResultName());
        case FIELD_statisticName: return oppstring2string(pp->getStatisticName());
        case FIELD_recordingMode: return oppstring2string(pp->getRecordingMode());
        default: return "";
    }
}

bool cResultRecorderDescriptor::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();
    }
    cResultRecorder *pp = (cResultRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cResultRecorderDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_component: return omnetpp::opp_typename(typeid(cComponent));
        default: return nullptr;
    };
}

void *cResultRecorderDescriptor::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();
    }
    cResultRecorder *pp = (cResultRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_component: return toVoidPtr(pp->getComponent()); break;
        default: return nullptr;
    }
}

class cNumericResultRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    cNumericResultRecorderDescriptor();
    virtual ~cNumericResultRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(cNumericResultRecorderDescriptor)

cNumericResultRecorderDescriptor::cNumericResultRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::cNumericResultRecorder)), "omnetpp::cResultRecorder")
{
    propertynames = nullptr;
}

cNumericResultRecorderDescriptor::~cNumericResultRecorderDescriptor()
{
    delete[] propertynames;
}

bool cNumericResultRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<cNumericResultRecorder *>(obj)!=nullptr;
}

const char **cNumericResultRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *cNumericResultRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int cNumericResultRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int cNumericResultRecorderDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *cNumericResultRecorderDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int cNumericResultRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *cNumericResultRecorderDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **cNumericResultRecorderDescriptor::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 *cNumericResultRecorderDescriptor::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 cNumericResultRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    cNumericResultRecorder *pp = (cNumericResultRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *cNumericResultRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    cNumericResultRecorder *pp = (cNumericResultRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string cNumericResultRecorderDescriptor::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();
    }
    cNumericResultRecorder *pp = (cNumericResultRecorder *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool cNumericResultRecorderDescriptor::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();
    }
    cNumericResultRecorder *pp = (cNumericResultRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *cNumericResultRecorderDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *cNumericResultRecorderDescriptor::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();
    }
    cNumericResultRecorder *pp = (cNumericResultRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class VectorRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_lastWriteTime,
        FIELD_lastValue,
    };
  public:
    VectorRecorderDescriptor();
    virtual ~VectorRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(VectorRecorderDescriptor)

VectorRecorderDescriptor::VectorRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::VectorRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

VectorRecorderDescriptor::~VectorRecorderDescriptor()
{
    delete[] propertynames;
}

bool VectorRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<VectorRecorder *>(obj)!=nullptr;
}

const char **VectorRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *VectorRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int VectorRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 2+basedesc->getFieldCount() : 2;
}

unsigned int VectorRecorderDescriptor::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[] = {
        0,    // FIELD_lastWriteTime
        0,    // FIELD_lastValue
    };
    return (field >= 0 && field < 2) ? fieldTypeFlags[field] : 0;
}

const char *VectorRecorderDescriptor::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[] = {
        "lastWriteTime",
        "lastValue",
    };
    return (field >= 0 && field < 2) ? fieldNames[field] : nullptr;
}

int VectorRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastWriteTime") == 0) return base+0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastValue") == 0) return base+1;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *VectorRecorderDescriptor::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[] = {
        "omnetpp::simtime_t",    // FIELD_lastWriteTime
        "double",    // FIELD_lastValue
    };
    return (field >= 0 && field < 2) ? fieldTypeStrings[field] : nullptr;
}

const char **VectorRecorderDescriptor::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 *VectorRecorderDescriptor::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 VectorRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    VectorRecorder *pp = (VectorRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *VectorRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    VectorRecorder *pp = (VectorRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string VectorRecorderDescriptor::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();
    }
    VectorRecorder *pp = (VectorRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_lastWriteTime: return simtime2string(pp->getLastWriteTime());
        case FIELD_lastValue: return double2string(pp->getLastValue());
        default: return "";
    }
}

bool VectorRecorderDescriptor::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();
    }
    VectorRecorder *pp = (VectorRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *VectorRecorderDescriptor::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 *VectorRecorderDescriptor::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();
    }
    VectorRecorder *pp = (VectorRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class CountRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_count,
    };
  public:
    CountRecorderDescriptor();
    virtual ~CountRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(CountRecorderDescriptor)

CountRecorderDescriptor::CountRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::CountRecorder)), "omnetpp::cResultRecorder")
{
    propertynames = nullptr;
}

CountRecorderDescriptor::~CountRecorderDescriptor()
{
    delete[] propertynames;
}

bool CountRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<CountRecorder *>(obj)!=nullptr;
}

const char **CountRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *CountRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int CountRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int CountRecorderDescriptor::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[] = {
        0,    // FIELD_count
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *CountRecorderDescriptor::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[] = {
        "count",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int CountRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "count") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *CountRecorderDescriptor::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[] = {
        "long",    // FIELD_count
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **CountRecorderDescriptor::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 *CountRecorderDescriptor::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 CountRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    CountRecorder *pp = (CountRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *CountRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    CountRecorder *pp = (CountRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string CountRecorderDescriptor::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();
    }
    CountRecorder *pp = (CountRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_count: return long2string(pp->getCount());
        default: return "";
    }
}

bool CountRecorderDescriptor::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();
    }
    CountRecorder *pp = (CountRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *CountRecorderDescriptor::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 *CountRecorderDescriptor::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();
    }
    CountRecorder *pp = (CountRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class LastValueRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_lastValue,
    };
  public:
    LastValueRecorderDescriptor();
    virtual ~LastValueRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(LastValueRecorderDescriptor)

LastValueRecorderDescriptor::LastValueRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::LastValueRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

LastValueRecorderDescriptor::~LastValueRecorderDescriptor()
{
    delete[] propertynames;
}

bool LastValueRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<LastValueRecorder *>(obj)!=nullptr;
}

const char **LastValueRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *LastValueRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int LastValueRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int LastValueRecorderDescriptor::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[] = {
        0,    // FIELD_lastValue
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *LastValueRecorderDescriptor::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[] = {
        "lastValue",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int LastValueRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastValue") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *LastValueRecorderDescriptor::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[] = {
        "double",    // FIELD_lastValue
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **LastValueRecorderDescriptor::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 *LastValueRecorderDescriptor::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 LastValueRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    LastValueRecorder *pp = (LastValueRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *LastValueRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    LastValueRecorder *pp = (LastValueRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string LastValueRecorderDescriptor::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();
    }
    LastValueRecorder *pp = (LastValueRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_lastValue: return double2string(pp->getLastValue());
        default: return "";
    }
}

bool LastValueRecorderDescriptor::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();
    }
    LastValueRecorder *pp = (LastValueRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *LastValueRecorderDescriptor::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 *LastValueRecorderDescriptor::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();
    }
    LastValueRecorder *pp = (LastValueRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class SumRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_sum,
    };
  public:
    SumRecorderDescriptor();
    virtual ~SumRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(SumRecorderDescriptor)

SumRecorderDescriptor::SumRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::SumRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

SumRecorderDescriptor::~SumRecorderDescriptor()
{
    delete[] propertynames;
}

bool SumRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<SumRecorder *>(obj)!=nullptr;
}

const char **SumRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *SumRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int SumRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int SumRecorderDescriptor::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[] = {
        0,    // FIELD_sum
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *SumRecorderDescriptor::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[] = {
        "sum",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int SumRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 's' && strcmp(fieldName, "sum") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *SumRecorderDescriptor::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[] = {
        "double",    // FIELD_sum
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **SumRecorderDescriptor::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 *SumRecorderDescriptor::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 SumRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    SumRecorder *pp = (SumRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *SumRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    SumRecorder *pp = (SumRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string SumRecorderDescriptor::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();
    }
    SumRecorder *pp = (SumRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_sum: return double2string(pp->getSum());
        default: return "";
    }
}

bool SumRecorderDescriptor::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();
    }
    SumRecorder *pp = (SumRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *SumRecorderDescriptor::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 *SumRecorderDescriptor::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();
    }
    SumRecorder *pp = (SumRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class MeanRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_mean,
    };
  public:
    MeanRecorderDescriptor();
    virtual ~MeanRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(MeanRecorderDescriptor)

MeanRecorderDescriptor::MeanRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::MeanRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

MeanRecorderDescriptor::~MeanRecorderDescriptor()
{
    delete[] propertynames;
}

bool MeanRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<MeanRecorder *>(obj)!=nullptr;
}

const char **MeanRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *MeanRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int MeanRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int MeanRecorderDescriptor::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[] = {
        0,    // FIELD_mean
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *MeanRecorderDescriptor::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[] = {
        "mean",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int MeanRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'm' && strcmp(fieldName, "mean") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *MeanRecorderDescriptor::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[] = {
        "double",    // FIELD_mean
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **MeanRecorderDescriptor::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 *MeanRecorderDescriptor::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 MeanRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    MeanRecorder *pp = (MeanRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *MeanRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    MeanRecorder *pp = (MeanRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string MeanRecorderDescriptor::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();
    }
    MeanRecorder *pp = (MeanRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_mean: return double2string(pp->getMean());
        default: return "";
    }
}

bool MeanRecorderDescriptor::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();
    }
    MeanRecorder *pp = (MeanRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *MeanRecorderDescriptor::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 *MeanRecorderDescriptor::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();
    }
    MeanRecorder *pp = (MeanRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class MinRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_min,
    };
  public:
    MinRecorderDescriptor();
    virtual ~MinRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(MinRecorderDescriptor)

MinRecorderDescriptor::MinRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::MinRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

MinRecorderDescriptor::~MinRecorderDescriptor()
{
    delete[] propertynames;
}

bool MinRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<MinRecorder *>(obj)!=nullptr;
}

const char **MinRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *MinRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int MinRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int MinRecorderDescriptor::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[] = {
        0,    // FIELD_min
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *MinRecorderDescriptor::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[] = {
        "min",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int MinRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'm' && strcmp(fieldName, "min") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *MinRecorderDescriptor::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[] = {
        "double",    // FIELD_min
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **MinRecorderDescriptor::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 *MinRecorderDescriptor::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 MinRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    MinRecorder *pp = (MinRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *MinRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    MinRecorder *pp = (MinRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string MinRecorderDescriptor::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();
    }
    MinRecorder *pp = (MinRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_min: return double2string(pp->getMin());
        default: return "";
    }
}

bool MinRecorderDescriptor::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();
    }
    MinRecorder *pp = (MinRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *MinRecorderDescriptor::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 *MinRecorderDescriptor::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();
    }
    MinRecorder *pp = (MinRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class MaxRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_max,
    };
  public:
    MaxRecorderDescriptor();
    virtual ~MaxRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(MaxRecorderDescriptor)

MaxRecorderDescriptor::MaxRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::MaxRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

MaxRecorderDescriptor::~MaxRecorderDescriptor()
{
    delete[] propertynames;
}

bool MaxRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<MaxRecorder *>(obj)!=nullptr;
}

const char **MaxRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *MaxRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int MaxRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int MaxRecorderDescriptor::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[] = {
        0,    // FIELD_max
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *MaxRecorderDescriptor::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[] = {
        "max",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int MaxRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'm' && strcmp(fieldName, "max") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *MaxRecorderDescriptor::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[] = {
        "double",    // FIELD_max
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **MaxRecorderDescriptor::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 *MaxRecorderDescriptor::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 MaxRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    MaxRecorder *pp = (MaxRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *MaxRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    MaxRecorder *pp = (MaxRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string MaxRecorderDescriptor::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();
    }
    MaxRecorder *pp = (MaxRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_max: return double2string(pp->getMax());
        default: return "";
    }
}

bool MaxRecorderDescriptor::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();
    }
    MaxRecorder *pp = (MaxRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *MaxRecorderDescriptor::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 *MaxRecorderDescriptor::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();
    }
    MaxRecorder *pp = (MaxRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class TimeAverageRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_timeAverage,
    };
  public:
    TimeAverageRecorderDescriptor();
    virtual ~TimeAverageRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(TimeAverageRecorderDescriptor)

TimeAverageRecorderDescriptor::TimeAverageRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::TimeAverageRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

TimeAverageRecorderDescriptor::~TimeAverageRecorderDescriptor()
{
    delete[] propertynames;
}

bool TimeAverageRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<TimeAverageRecorder *>(obj)!=nullptr;
}

const char **TimeAverageRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *TimeAverageRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int TimeAverageRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int TimeAverageRecorderDescriptor::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[] = {
        0,    // FIELD_timeAverage
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *TimeAverageRecorderDescriptor::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[] = {
        "timeAverage",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int TimeAverageRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 't' && strcmp(fieldName, "timeAverage") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *TimeAverageRecorderDescriptor::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[] = {
        "double",    // FIELD_timeAverage
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **TimeAverageRecorderDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_timeAverage: {
            static const char *names[] = { "hint",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *TimeAverageRecorderDescriptor::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 FIELD_timeAverage:
            if (!strcmp(propertyname, "hint")) return "Computed with the CURRENT simulation time";
            return nullptr;
        default: return nullptr;
    }
}

int TimeAverageRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    TimeAverageRecorder *pp = (TimeAverageRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *TimeAverageRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    TimeAverageRecorder *pp = (TimeAverageRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string TimeAverageRecorderDescriptor::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();
    }
    TimeAverageRecorder *pp = (TimeAverageRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_timeAverage: return double2string(pp->getTimeAverage());
        default: return "";
    }
}

bool TimeAverageRecorderDescriptor::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();
    }
    TimeAverageRecorder *pp = (TimeAverageRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *TimeAverageRecorderDescriptor::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 *TimeAverageRecorderDescriptor::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();
    }
    TimeAverageRecorder *pp = (TimeAverageRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class StatisticsRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_statistic,
    };
  public:
    StatisticsRecorderDescriptor();
    virtual ~StatisticsRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(StatisticsRecorderDescriptor)

StatisticsRecorderDescriptor::StatisticsRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::StatisticsRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

StatisticsRecorderDescriptor::~StatisticsRecorderDescriptor()
{
    delete[] propertynames;
}

bool StatisticsRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<StatisticsRecorder *>(obj)!=nullptr;
}

const char **StatisticsRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *StatisticsRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int StatisticsRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 1+basedesc->getFieldCount() : 1;
}

unsigned int StatisticsRecorderDescriptor::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_ISCOMPOUND | FD_ISPOINTER | FD_ISCOBJECT | FD_ISCOWNEDOBJECT,    // FIELD_statistic
    };
    return (field >= 0 && field < 1) ? fieldTypeFlags[field] : 0;
}

const char *StatisticsRecorderDescriptor::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[] = {
        "statistic",
    };
    return (field >= 0 && field < 1) ? fieldNames[field] : nullptr;
}

int StatisticsRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 's' && strcmp(fieldName, "statistic") == 0) return base+0;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *StatisticsRecorderDescriptor::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[] = {
        "omnetpp::cStatistic",    // FIELD_statistic
    };
    return (field >= 0 && field < 1) ? fieldTypeStrings[field] : nullptr;
}

const char **StatisticsRecorderDescriptor::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 *StatisticsRecorderDescriptor::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 StatisticsRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    StatisticsRecorder *pp = (StatisticsRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *StatisticsRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    StatisticsRecorder *pp = (StatisticsRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_statistic: { const cStatistic * value = pp->getStatistic(); return omnetpp::opp_typename(typeid(*value)); }
        default: return nullptr;
    }
}

std::string StatisticsRecorderDescriptor::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();
    }
    StatisticsRecorder *pp = (StatisticsRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_statistic: {std::stringstream out; out << pp->getStatistic(); return out.str();}
        default: return "";
    }
}

bool StatisticsRecorderDescriptor::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();
    }
    StatisticsRecorder *pp = (StatisticsRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *StatisticsRecorderDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_statistic: return omnetpp::opp_typename(typeid(cStatistic));
        default: return nullptr;
    };
}

void *StatisticsRecorderDescriptor::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();
    }
    StatisticsRecorder *pp = (StatisticsRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_statistic: return toVoidPtr(pp->getStatistic()); break;
        default: return nullptr;
    }
}

class StatsRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    StatsRecorderDescriptor();
    virtual ~StatsRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(StatsRecorderDescriptor)

StatsRecorderDescriptor::StatsRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::StatsRecorder)), "omnetpp::StatisticsRecorder")
{
    propertynames = nullptr;
}

StatsRecorderDescriptor::~StatsRecorderDescriptor()
{
    delete[] propertynames;
}

bool StatsRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<StatsRecorder *>(obj)!=nullptr;
}

const char **StatsRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *StatsRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int StatsRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int StatsRecorderDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *StatsRecorderDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int StatsRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *StatsRecorderDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **StatsRecorderDescriptor::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 *StatsRecorderDescriptor::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 StatsRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    StatsRecorder *pp = (StatsRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *StatsRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    StatsRecorder *pp = (StatsRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string StatsRecorderDescriptor::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();
    }
    StatsRecorder *pp = (StatsRecorder *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool StatsRecorderDescriptor::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();
    }
    StatsRecorder *pp = (StatsRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *StatsRecorderDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *StatsRecorderDescriptor::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();
    }
    StatsRecorder *pp = (StatsRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class HistogramRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    HistogramRecorderDescriptor();
    virtual ~HistogramRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(HistogramRecorderDescriptor)

HistogramRecorderDescriptor::HistogramRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::HistogramRecorder)), "omnetpp::StatisticsRecorder")
{
    propertynames = nullptr;
}

HistogramRecorderDescriptor::~HistogramRecorderDescriptor()
{
    delete[] propertynames;
}

bool HistogramRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<HistogramRecorder *>(obj)!=nullptr;
}

const char **HistogramRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *HistogramRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int HistogramRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int HistogramRecorderDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *HistogramRecorderDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int HistogramRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *HistogramRecorderDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **HistogramRecorderDescriptor::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 *HistogramRecorderDescriptor::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 HistogramRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    HistogramRecorder *pp = (HistogramRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *HistogramRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    HistogramRecorder *pp = (HistogramRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string HistogramRecorderDescriptor::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();
    }
    HistogramRecorder *pp = (HistogramRecorder *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool HistogramRecorderDescriptor::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();
    }
    HistogramRecorder *pp = (HistogramRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *HistogramRecorderDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *HistogramRecorderDescriptor::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();
    }
    HistogramRecorder *pp = (HistogramRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class KSplitRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    KSplitRecorderDescriptor();
    virtual ~KSplitRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(KSplitRecorderDescriptor)

KSplitRecorderDescriptor::KSplitRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::KSplitRecorder)), "omnetpp::StatisticsRecorder")
{
    propertynames = nullptr;
}

KSplitRecorderDescriptor::~KSplitRecorderDescriptor()
{
    delete[] propertynames;
}

bool KSplitRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<KSplitRecorder *>(obj)!=nullptr;
}

const char **KSplitRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *KSplitRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int KSplitRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int KSplitRecorderDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *KSplitRecorderDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int KSplitRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *KSplitRecorderDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **KSplitRecorderDescriptor::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 *KSplitRecorderDescriptor::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 KSplitRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    KSplitRecorder *pp = (KSplitRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *KSplitRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    KSplitRecorder *pp = (KSplitRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string KSplitRecorderDescriptor::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();
    }
    KSplitRecorder *pp = (KSplitRecorder *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool KSplitRecorderDescriptor::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();
    }
    KSplitRecorder *pp = (KSplitRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *KSplitRecorderDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *KSplitRecorderDescriptor::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();
    }
    KSplitRecorder *pp = (KSplitRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class PSquareRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
    };
  public:
    PSquareRecorderDescriptor();
    virtual ~PSquareRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(PSquareRecorderDescriptor)

PSquareRecorderDescriptor::PSquareRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::PSquareRecorder)), "omnetpp::StatisticsRecorder")
{
    propertynames = nullptr;
}

PSquareRecorderDescriptor::~PSquareRecorderDescriptor()
{
    delete[] propertynames;
}

bool PSquareRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<PSquareRecorder *>(obj)!=nullptr;
}

const char **PSquareRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *PSquareRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int PSquareRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 0+basedesc->getFieldCount() : 0;
}

unsigned int PSquareRecorderDescriptor::getFieldTypeFlags(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeFlags(field);
        field -= basedesc->getFieldCount();
    }
    return 0;
}

const char *PSquareRecorderDescriptor::getFieldName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

int PSquareRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *PSquareRecorderDescriptor::getFieldTypeString(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldTypeString(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

const char **PSquareRecorderDescriptor::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 *PSquareRecorderDescriptor::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 PSquareRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    PSquareRecorder *pp = (PSquareRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *PSquareRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    PSquareRecorder *pp = (PSquareRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string PSquareRecorderDescriptor::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();
    }
    PSquareRecorder *pp = (PSquareRecorder *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool PSquareRecorderDescriptor::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();
    }
    PSquareRecorder *pp = (PSquareRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *PSquareRecorderDescriptor::getFieldStructName(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldStructName(field);
        field -= basedesc->getFieldCount();
    }
    return nullptr;
}

void *PSquareRecorderDescriptor::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();
    }
    PSquareRecorder *pp = (PSquareRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

class ExpressionRecorderDescriptor : public omnetpp::cClassDescriptor
{
  private:
    mutable const char **propertynames;
    enum FieldConstants {
        FIELD_expression,
        FIELD_currentValue,
        FIELD_lastInputValue,
    };
  public:
    ExpressionRecorderDescriptor();
    virtual ~ExpressionRecorderDescriptor();

    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 const char *getFieldDynamicTypeString(void *object, int field, int i) 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(ExpressionRecorderDescriptor)

ExpressionRecorderDescriptor::ExpressionRecorderDescriptor() : omnetpp::cClassDescriptor(omnetpp::opp_typename(typeid(omnetpp::ExpressionRecorder)), "omnetpp::cNumericResultRecorder")
{
    propertynames = nullptr;
}

ExpressionRecorderDescriptor::~ExpressionRecorderDescriptor()
{
    delete[] propertynames;
}

bool ExpressionRecorderDescriptor::doesSupport(omnetpp::cObject *obj) const
{
    return dynamic_cast<ExpressionRecorder *>(obj)!=nullptr;
}

const char **ExpressionRecorderDescriptor::getPropertyNames() const
{
    if (!propertynames) {
        static const char *names[] = { "existingClass", "overwritePreviousDefinition", "descriptor",  nullptr };
        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
        propertynames = mergeLists(basenames, names);
    }
    return propertynames;
}

const char *ExpressionRecorderDescriptor::getProperty(const char *propertyname) const
{
    if (!strcmp(propertyname, "existingClass")) return "";
    if (!strcmp(propertyname, "overwritePreviousDefinition")) return "";
    if (!strcmp(propertyname, "descriptor")) return "readonly";
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
}

int ExpressionRecorderDescriptor::getFieldCount() const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? 3+basedesc->getFieldCount() : 3;
}

unsigned int ExpressionRecorderDescriptor::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[] = {
        0,    // FIELD_expression
        0,    // FIELD_currentValue
        0,    // FIELD_lastInputValue
    };
    return (field >= 0 && field < 3) ? fieldTypeFlags[field] : 0;
}

const char *ExpressionRecorderDescriptor::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[] = {
        "expression",
        "currentValue",
        "lastInputValue",
    };
    return (field >= 0 && field < 3) ? fieldNames[field] : nullptr;
}

int ExpressionRecorderDescriptor::findField(const char *fieldName) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount() : 0;
    if (fieldName[0] == 'e' && strcmp(fieldName, "expression") == 0) return base+0;
    if (fieldName[0] == 'c' && strcmp(fieldName, "currentValue") == 0) return base+1;
    if (fieldName[0] == 'l' && strcmp(fieldName, "lastInputValue") == 0) return base+2;
    return basedesc ? basedesc->findField(fieldName) : -1;
}

const char *ExpressionRecorderDescriptor::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",    // FIELD_expression
        "double",    // FIELD_currentValue
        "double",    // FIELD_lastInputValue
    };
    return (field >= 0 && field < 3) ? fieldTypeStrings[field] : nullptr;
}

const char **ExpressionRecorderDescriptor::getFieldPropertyNames(int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldPropertyNames(field);
        field -= basedesc->getFieldCount();
    }
    switch (field) {
        case FIELD_expression: {
            static const char *names[] = { "toString",  nullptr };
            return names;
        }
        default: return nullptr;
    }
}

const char *ExpressionRecorderDescriptor::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 FIELD_expression:
            if (!strcmp(propertyname, "toString")) return ".str()";
            return nullptr;
        default: return nullptr;
    }
}

int ExpressionRecorderDescriptor::getFieldArraySize(void *object, int field) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldArraySize(object, field);
        field -= basedesc->getFieldCount();
    }
    ExpressionRecorder *pp = (ExpressionRecorder *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

const char *ExpressionRecorderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
{
    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount())
            return basedesc->getFieldDynamicTypeString(object,field,i);
        field -= basedesc->getFieldCount();
    }
    ExpressionRecorder *pp = (ExpressionRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

std::string ExpressionRecorderDescriptor::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();
    }
    ExpressionRecorder *pp = (ExpressionRecorder *)object; (void)pp;
    switch (field) {
        case FIELD_expression: return pp->getExpression().str();
        case FIELD_currentValue: return double2string(pp->getCurrentValue());
        case FIELD_lastInputValue: return double2string(pp->getLastInputValue());
        default: return "";
    }
}

bool ExpressionRecorderDescriptor::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();
    }
    ExpressionRecorder *pp = (ExpressionRecorder *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *ExpressionRecorderDescriptor::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 *ExpressionRecorderDescriptor::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();
    }
    ExpressionRecorder *pp = (ExpressionRecorder *)object; (void)pp;
    switch (field) {
        default: return nullptr;
    }
}

} // namespace omnetpp