//
// Generated file, do not edit! Created by opp_msgc 4.1 from overlay/mychord/MyChordMessage.msg.
//

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

#include <iostream>
#include <sstream>
#include "MyChordMessage_m.h"

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

// Another default rule (prevents compiler from choosing base class' doPacking())
template<typename T>
void doPacking(cCommBuffer *, T& t) {
    throw cRuntimeError("Parsim error: no doPacking() function for type %s or its base class (check .msg and _m.cc/h files!)",opp_typename(typeid(t)));
}

template<typename T>
void doUnpacking(cCommBuffer *, T& t) {
    throw cRuntimeError("Parsim error: no doUnpacking() function for type %s or its base class (check .msg and _m.cc/h files!)",opp_typename(typeid(t)));
}




EXECUTE_ON_STARTUP(
    cEnum *e = cEnum::find("ChordCommand");
    if (!e) enums.getInstance()->add(e = new cEnum("ChordCommand"));
    e->insert(NEWSUCCESSORHINT, "NEWSUCCESSORHINT");
    e->insert(FINDGROUPMEMBER, "FINDGROUPMEMBER");
    e->insert(FINDGROUPMEMBERREPLY, "FINDGROUPMEMBERREPLY");
);

Register_Class(MyChordMessage);

MyChordMessage::MyChordMessage(const char *name, int kind) : BaseOverlayMessage(name,kind)
{
    this->command_var = 0;
}

MyChordMessage::MyChordMessage(const MyChordMessage& other) : BaseOverlayMessage()
{
    setName(other.getName());
    operator=(other);
}

MyChordMessage::~MyChordMessage()
{
}

MyChordMessage& MyChordMessage::operator=(const MyChordMessage& other)
{
    if (this==&other) return *this;
    BaseOverlayMessage::operator=(other);
    this->command_var = other.command_var;
    return *this;
}

void MyChordMessage::parsimPack(cCommBuffer *b)
{
    BaseOverlayMessage::parsimPack(b);
    doPacking(b,this->command_var);
}

void MyChordMessage::parsimUnpack(cCommBuffer *b)
{
    BaseOverlayMessage::parsimUnpack(b);
    doUnpacking(b,this->command_var);
}

int MyChordMessage::getCommand() const
{
    return command_var;
}

void MyChordMessage::setCommand(int command_var)
{
    this->command_var = command_var;
}

class MyChordMessageDescriptor : public cClassDescriptor
{
  public:
    MyChordMessageDescriptor();
    virtual ~MyChordMessageDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyChordMessageDescriptor);

MyChordMessageDescriptor::MyChordMessageDescriptor() : cClassDescriptor("MyChordMessage", "BaseOverlayMessage")
{
}

MyChordMessageDescriptor::~MyChordMessageDescriptor()
{
}

bool MyChordMessageDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyChordMessage *>(obj)!=NULL;
}

const char *MyChordMessageDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

unsigned int MyChordMessageDescriptor::getFieldTypeFlags(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeFlags(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static unsigned int fieldTypeFlags[] = {
        FD_ISEDITABLE,
    };
    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
}

const char *MyChordMessageDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "command",
    };
    return (field>=0 && field<1) ? fieldNames[field] : NULL;
}

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

const char *MyChordMessageDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "int",
    };
    return (field>=0 && field<1) ? fieldTypeStrings[field] : NULL;
}

const char *MyChordMessageDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        case 0:
            if (!strcmp(propertyname,"enum")) return "ChordCommand";
            return NULL;
        default: return NULL;
    }
}

int MyChordMessageDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyChordMessage *pp = (MyChordMessage *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string MyChordMessageDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyChordMessage *pp = (MyChordMessage *)object; (void)pp;
    switch (field) {
        case 0: return long2string(pp->getCommand());
        default: return "";
    }
}

bool MyChordMessageDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyChordMessage *pp = (MyChordMessage *)object; (void)pp;
    switch (field) {
        case 0: pp->setCommand(string2long(value)); return true;
        default: return false;
    }
}

const char *MyChordMessageDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        NULL,
    };
    return (field>=0 && field<1) ? fieldStructNames[field] : NULL;
}

void *MyChordMessageDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyChordMessage *pp = (MyChordMessage *)object; (void)pp;
    switch (field) {
        default: return NULL;
    }
}

Register_Class(MyNewSuccessorHintMessage);

MyNewSuccessorHintMessage::MyNewSuccessorHintMessage(const char *name, int kind) : MyChordMessage(name,kind)
{
    this->srcGroupId_var = 0;
    this->preGroupId_var = 0;
}

MyNewSuccessorHintMessage::MyNewSuccessorHintMessage(const MyNewSuccessorHintMessage& other) : MyChordMessage()
{
    setName(other.getName());
    operator=(other);
}

MyNewSuccessorHintMessage::~MyNewSuccessorHintMessage()
{
}

MyNewSuccessorHintMessage& MyNewSuccessorHintMessage::operator=(const MyNewSuccessorHintMessage& other)
{
    if (this==&other) return *this;
    MyChordMessage::operator=(other);
    this->srcNode_var = other.srcNode_var;
    this->preNode_var = other.preNode_var;
    this->srcGroupId_var = other.srcGroupId_var;
    this->preGroupId_var = other.preGroupId_var;
    return *this;
}

void MyNewSuccessorHintMessage::parsimPack(cCommBuffer *b)
{
    MyChordMessage::parsimPack(b);
    doPacking(b,this->srcNode_var);
    doPacking(b,this->preNode_var);
    doPacking(b,this->srcGroupId_var);
    doPacking(b,this->preGroupId_var);
}

void MyNewSuccessorHintMessage::parsimUnpack(cCommBuffer *b)
{
    MyChordMessage::parsimUnpack(b);
    doUnpacking(b,this->srcNode_var);
    doUnpacking(b,this->preNode_var);
    doUnpacking(b,this->srcGroupId_var);
    doUnpacking(b,this->preGroupId_var);
}

NodeHandle& MyNewSuccessorHintMessage::getSrcNode()
{
    return srcNode_var;
}

void MyNewSuccessorHintMessage::setSrcNode(const NodeHandle& srcNode_var)
{
    this->srcNode_var = srcNode_var;
}

NodeHandle& MyNewSuccessorHintMessage::getPreNode()
{
    return preNode_var;
}

void MyNewSuccessorHintMessage::setPreNode(const NodeHandle& preNode_var)
{
    this->preNode_var = preNode_var;
}

int MyNewSuccessorHintMessage::getSrcGroupId() const
{
    return srcGroupId_var;
}

void MyNewSuccessorHintMessage::setSrcGroupId(int srcGroupId_var)
{
    this->srcGroupId_var = srcGroupId_var;
}

int MyNewSuccessorHintMessage::getPreGroupId() const
{
    return preGroupId_var;
}

void MyNewSuccessorHintMessage::setPreGroupId(int preGroupId_var)
{
    this->preGroupId_var = preGroupId_var;
}

class MyNewSuccessorHintMessageDescriptor : public cClassDescriptor
{
  public:
    MyNewSuccessorHintMessageDescriptor();
    virtual ~MyNewSuccessorHintMessageDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyNewSuccessorHintMessageDescriptor);

MyNewSuccessorHintMessageDescriptor::MyNewSuccessorHintMessageDescriptor() : cClassDescriptor("MyNewSuccessorHintMessage", "MyChordMessage")
{
}

MyNewSuccessorHintMessageDescriptor::~MyNewSuccessorHintMessageDescriptor()
{
}

bool MyNewSuccessorHintMessageDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyNewSuccessorHintMessage *>(obj)!=NULL;
}

const char *MyNewSuccessorHintMessageDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

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

const char *MyNewSuccessorHintMessageDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "srcNode",
        "preNode",
        "srcGroupId",
        "preGroupId",
    };
    return (field>=0 && field<4) ? fieldNames[field] : NULL;
}

int MyNewSuccessorHintMessageDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcNode")==0) return base+0;
    if (fieldName[0]=='p' && strcmp(fieldName, "preNode")==0) return base+1;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcGroupId")==0) return base+2;
    if (fieldName[0]=='p' && strcmp(fieldName, "preGroupId")==0) return base+3;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyNewSuccessorHintMessageDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "NodeHandle",
        "NodeHandle",
        "int",
        "int",
    };
    return (field>=0 && field<4) ? fieldTypeStrings[field] : NULL;
}

const char *MyNewSuccessorHintMessageDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyNewSuccessorHintMessageDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyNewSuccessorHintMessage *pp = (MyNewSuccessorHintMessage *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string MyNewSuccessorHintMessageDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyNewSuccessorHintMessage *pp = (MyNewSuccessorHintMessage *)object; (void)pp;
    switch (field) {
        case 0: {std::stringstream out; out << pp->getSrcNode(); return out.str();}
        case 1: {std::stringstream out; out << pp->getPreNode(); return out.str();}
        case 2: return long2string(pp->getSrcGroupId());
        case 3: return long2string(pp->getPreGroupId());
        default: return "";
    }
}

bool MyNewSuccessorHintMessageDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyNewSuccessorHintMessage *pp = (MyNewSuccessorHintMessage *)object; (void)pp;
    switch (field) {
        case 2: pp->setSrcGroupId(string2long(value)); return true;
        case 3: pp->setPreGroupId(string2long(value)); return true;
        default: return false;
    }
}

const char *MyNewSuccessorHintMessageDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        "NodeHandle",
        "NodeHandle",
        NULL,
        NULL,
    };
    return (field>=0 && field<4) ? fieldStructNames[field] : NULL;
}

void *MyNewSuccessorHintMessageDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyNewSuccessorHintMessage *pp = (MyNewSuccessorHintMessage *)object; (void)pp;
    switch (field) {
        case 0: return (void *)(&pp->getSrcNode()); break;
        case 1: return (void *)(&pp->getPreNode()); break;
        default: return NULL;
    }
}

Register_Class(MyNotifyCall);

MyNotifyCall::MyNotifyCall(const char *name, int kind) : BaseCallMessage(name,kind)
{
    this->failed_var = TransportAddress::UNSPECIFIED_NODE;
    this->srcGroupId_var = 0;
}

MyNotifyCall::MyNotifyCall(const MyNotifyCall& other) : BaseCallMessage()
{
    setName(other.getName());
    operator=(other);
}

MyNotifyCall::~MyNotifyCall()
{
}

MyNotifyCall& MyNotifyCall::operator=(const MyNotifyCall& other)
{
    if (this==&other) return *this;
    BaseCallMessage::operator=(other);
    this->failed_var = other.failed_var;
    this->srcGroupId_var = other.srcGroupId_var;
    return *this;
}

void MyNotifyCall::parsimPack(cCommBuffer *b)
{
    BaseCallMessage::parsimPack(b);
    doPacking(b,this->failed_var);
    doPacking(b,this->srcGroupId_var);
}

void MyNotifyCall::parsimUnpack(cCommBuffer *b)
{
    BaseCallMessage::parsimUnpack(b);
    doUnpacking(b,this->failed_var);
    doUnpacking(b,this->srcGroupId_var);
}

TransportAddress& MyNotifyCall::getFailed()
{
    return failed_var;
}

void MyNotifyCall::setFailed(const TransportAddress& failed_var)
{
    this->failed_var = failed_var;
}

int MyNotifyCall::getSrcGroupId() const
{
    return srcGroupId_var;
}

void MyNotifyCall::setSrcGroupId(int srcGroupId_var)
{
    this->srcGroupId_var = srcGroupId_var;
}

class MyNotifyCallDescriptor : public cClassDescriptor
{
  public:
    MyNotifyCallDescriptor();
    virtual ~MyNotifyCallDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyNotifyCallDescriptor);

MyNotifyCallDescriptor::MyNotifyCallDescriptor() : cClassDescriptor("MyNotifyCall", "BaseCallMessage")
{
}

MyNotifyCallDescriptor::~MyNotifyCallDescriptor()
{
}

bool MyNotifyCallDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyNotifyCall *>(obj)!=NULL;
}

const char *MyNotifyCallDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

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

const char *MyNotifyCallDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "failed",
        "srcGroupId",
    };
    return (field>=0 && field<2) ? fieldNames[field] : NULL;
}

int MyNotifyCallDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "failed")==0) return base+0;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcGroupId")==0) return base+1;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyNotifyCallDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "TransportAddress",
        "int",
    };
    return (field>=0 && field<2) ? fieldTypeStrings[field] : NULL;
}

const char *MyNotifyCallDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyNotifyCallDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyNotifyCall *pp = (MyNotifyCall *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string MyNotifyCallDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyNotifyCall *pp = (MyNotifyCall *)object; (void)pp;
    switch (field) {
        case 0: {std::stringstream out; out << pp->getFailed(); return out.str();}
        case 1: return long2string(pp->getSrcGroupId());
        default: return "";
    }
}

bool MyNotifyCallDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyNotifyCall *pp = (MyNotifyCall *)object; (void)pp;
    switch (field) {
        case 1: pp->setSrcGroupId(string2long(value)); return true;
        default: return false;
    }
}

const char *MyNotifyCallDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        "TransportAddress",
        NULL,
    };
    return (field>=0 && field<2) ? fieldStructNames[field] : NULL;
}

void *MyNotifyCallDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyNotifyCall *pp = (MyNotifyCall *)object; (void)pp;
    switch (field) {
        case 0: return (void *)(&pp->getFailed()); break;
        default: return NULL;
    }
}

Register_Class(MyNotifyResponse);

MyNotifyResponse::MyNotifyResponse(const char *name, int kind) : BaseResponseMessage(name,kind)
{
    this->sucNum_var = 0;
    this->srcGroupId_var = 0;
    sucNode_arraysize = 0;
    this->sucNode_var = 0;
    sucGroupId_arraysize = 0;
    this->sucGroupId_var = 0;
    this->preGroupId_var = 0;
    this->preNodeSet_var = 0;
}

MyNotifyResponse::MyNotifyResponse(const MyNotifyResponse& other) : BaseResponseMessage()
{
    setName(other.getName());
    sucNode_arraysize = 0;
    this->sucNode_var = 0;
    sucGroupId_arraysize = 0;
    this->sucGroupId_var = 0;
    operator=(other);
}

MyNotifyResponse::~MyNotifyResponse()
{
    delete [] sucNode_var;
    delete [] sucGroupId_var;
}

MyNotifyResponse& MyNotifyResponse::operator=(const MyNotifyResponse& other)
{
    if (this==&other) return *this;
    BaseResponseMessage::operator=(other);
    this->sucNum_var = other.sucNum_var;
    this->srcGroupId_var = other.srcGroupId_var;
    delete [] this->sucNode_var;
    this->sucNode_var = (other.sucNode_arraysize==0) ? NULL : new ::NodeHandle[other.sucNode_arraysize];
    sucNode_arraysize = other.sucNode_arraysize;
    for (unsigned int i=0; i<sucNode_arraysize; i++)
        this->sucNode_var[i] = other.sucNode_var[i];
    delete [] this->sucGroupId_var;
    this->sucGroupId_var = (other.sucGroupId_arraysize==0) ? NULL : new int[other.sucGroupId_arraysize];
    sucGroupId_arraysize = other.sucGroupId_arraysize;
    for (unsigned int i=0; i<sucGroupId_arraysize; i++)
        this->sucGroupId_var[i] = other.sucGroupId_var[i];
    this->preNode_var = other.preNode_var;
    this->preGroupId_var = other.preGroupId_var;
    this->preNodeSet_var = other.preNodeSet_var;
    return *this;
}

void MyNotifyResponse::parsimPack(cCommBuffer *b)
{
    BaseResponseMessage::parsimPack(b);
    doPacking(b,this->sucNum_var);
    doPacking(b,this->srcGroupId_var);
    b->pack(sucNode_arraysize);
    doPacking(b,this->sucNode_var,sucNode_arraysize);
    b->pack(sucGroupId_arraysize);
    doPacking(b,this->sucGroupId_var,sucGroupId_arraysize);
    doPacking(b,this->preNode_var);
    doPacking(b,this->preGroupId_var);
    doPacking(b,this->preNodeSet_var);
}

void MyNotifyResponse::parsimUnpack(cCommBuffer *b)
{
    BaseResponseMessage::parsimUnpack(b);
    doUnpacking(b,this->sucNum_var);
    doUnpacking(b,this->srcGroupId_var);
    delete [] this->sucNode_var;
    b->unpack(sucNode_arraysize);
    if (sucNode_arraysize==0) {
        this->sucNode_var = 0;
    } else {
        this->sucNode_var = new ::NodeHandle[sucNode_arraysize];
        doUnpacking(b,this->sucNode_var,sucNode_arraysize);
    }
    delete [] this->sucGroupId_var;
    b->unpack(sucGroupId_arraysize);
    if (sucGroupId_arraysize==0) {
        this->sucGroupId_var = 0;
    } else {
        this->sucGroupId_var = new int[sucGroupId_arraysize];
        doUnpacking(b,this->sucGroupId_var,sucGroupId_arraysize);
    }
    doUnpacking(b,this->preNode_var);
    doUnpacking(b,this->preGroupId_var);
    doUnpacking(b,this->preNodeSet_var);
}

int MyNotifyResponse::getSucNum() const
{
    return sucNum_var;
}

void MyNotifyResponse::setSucNum(int sucNum_var)
{
    this->sucNum_var = sucNum_var;
}

int MyNotifyResponse::getSrcGroupId() const
{
    return srcGroupId_var;
}

void MyNotifyResponse::setSrcGroupId(int srcGroupId_var)
{
    this->srcGroupId_var = srcGroupId_var;
}

void MyNotifyResponse::setSucNodeArraySize(unsigned int size)
{
    ::NodeHandle *sucNode_var2 = (size==0) ? NULL : new ::NodeHandle[size];
    unsigned int sz = sucNode_arraysize < size ? sucNode_arraysize : size;
    for (unsigned int i=0; i<sz; i++)
        sucNode_var2[i] = this->sucNode_var[i];
    sucNode_arraysize = size;
    delete [] this->sucNode_var;
    this->sucNode_var = sucNode_var2;
}

unsigned int MyNotifyResponse::getSucNodeArraySize() const
{
    return sucNode_arraysize;
}

NodeHandle& MyNotifyResponse::getSucNode(unsigned int k)
{
    if (k>=sucNode_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucNode_arraysize, k);
    return sucNode_var[k];
}

void MyNotifyResponse::setSucNode(unsigned int k, const NodeHandle& sucNode_var)
{
    if (k>=sucNode_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucNode_arraysize, k);
    this->sucNode_var[k]=sucNode_var;
}

void MyNotifyResponse::setSucGroupIdArraySize(unsigned int size)
{
    int *sucGroupId_var2 = (size==0) ? NULL : new int[size];
    unsigned int sz = sucGroupId_arraysize < size ? sucGroupId_arraysize : size;
    for (unsigned int i=0; i<sz; i++)
        sucGroupId_var2[i] = this->sucGroupId_var[i];
    for (unsigned int i=sz; i<size; i++)
        sucGroupId_var2[i] = 0;
    sucGroupId_arraysize = size;
    delete [] this->sucGroupId_var;
    this->sucGroupId_var = sucGroupId_var2;
}

unsigned int MyNotifyResponse::getSucGroupIdArraySize() const
{
    return sucGroupId_arraysize;
}

int MyNotifyResponse::getSucGroupId(unsigned int k) const
{
    if (k>=sucGroupId_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucGroupId_arraysize, k);
    return sucGroupId_var[k];
}

void MyNotifyResponse::setSucGroupId(unsigned int k, int sucGroupId_var)
{
    if (k>=sucGroupId_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucGroupId_arraysize, k);
    this->sucGroupId_var[k]=sucGroupId_var;
}

NodeHandle& MyNotifyResponse::getPreNode()
{
    return preNode_var;
}

void MyNotifyResponse::setPreNode(const NodeHandle& preNode_var)
{
    this->preNode_var = preNode_var;
}

int MyNotifyResponse::getPreGroupId() const
{
    return preGroupId_var;
}

void MyNotifyResponse::setPreGroupId(int preGroupId_var)
{
    this->preGroupId_var = preGroupId_var;
}

bool MyNotifyResponse::getPreNodeSet() const
{
    return preNodeSet_var;
}

void MyNotifyResponse::setPreNodeSet(bool preNodeSet_var)
{
    this->preNodeSet_var = preNodeSet_var;
}

class MyNotifyResponseDescriptor : public cClassDescriptor
{
  public:
    MyNotifyResponseDescriptor();
    virtual ~MyNotifyResponseDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyNotifyResponseDescriptor);

MyNotifyResponseDescriptor::MyNotifyResponseDescriptor() : cClassDescriptor("MyNotifyResponse", "BaseResponseMessage")
{
}

MyNotifyResponseDescriptor::~MyNotifyResponseDescriptor()
{
}

bool MyNotifyResponseDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyNotifyResponse *>(obj)!=NULL;
}

const char *MyNotifyResponseDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

unsigned int MyNotifyResponseDescriptor::getFieldTypeFlags(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeFlags(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static unsigned int fieldTypeFlags[] = {
        FD_ISEDITABLE,
        FD_ISEDITABLE,
        FD_ISARRAY | FD_ISCOMPOUND,
        FD_ISARRAY | FD_ISEDITABLE,
        FD_ISCOMPOUND,
        FD_ISEDITABLE,
        FD_ISEDITABLE,
    };
    return (field>=0 && field<7) ? fieldTypeFlags[field] : 0;
}

const char *MyNotifyResponseDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "sucNum",
        "srcGroupId",
        "sucNode",
        "sucGroupId",
        "preNode",
        "preGroupId",
        "preNodeSet",
    };
    return (field>=0 && field<7) ? fieldNames[field] : NULL;
}

int MyNotifyResponseDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucNum")==0) return base+0;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcGroupId")==0) return base+1;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucNode")==0) return base+2;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucGroupId")==0) return base+3;
    if (fieldName[0]=='p' && strcmp(fieldName, "preNode")==0) return base+4;
    if (fieldName[0]=='p' && strcmp(fieldName, "preGroupId")==0) return base+5;
    if (fieldName[0]=='p' && strcmp(fieldName, "preNodeSet")==0) return base+6;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyNotifyResponseDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "int",
        "int",
        "NodeHandle",
        "int",
        "NodeHandle",
        "int",
        "bool",
    };
    return (field>=0 && field<7) ? fieldTypeStrings[field] : NULL;
}

const char *MyNotifyResponseDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyNotifyResponseDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyNotifyResponse *pp = (MyNotifyResponse *)object; (void)pp;
    switch (field) {
        case 2: return pp->getSucNodeArraySize();
        case 3: return pp->getSucGroupIdArraySize();
        default: return 0;
    }
}

std::string MyNotifyResponseDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyNotifyResponse *pp = (MyNotifyResponse *)object; (void)pp;
    switch (field) {
        case 0: return long2string(pp->getSucNum());
        case 1: return long2string(pp->getSrcGroupId());
        case 2: {std::stringstream out; out << pp->getSucNode(i); return out.str();}
        case 3: return long2string(pp->getSucGroupId(i));
        case 4: {std::stringstream out; out << pp->getPreNode(); return out.str();}
        case 5: return long2string(pp->getPreGroupId());
        case 6: return bool2string(pp->getPreNodeSet());
        default: return "";
    }
}

bool MyNotifyResponseDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyNotifyResponse *pp = (MyNotifyResponse *)object; (void)pp;
    switch (field) {
        case 0: pp->setSucNum(string2long(value)); return true;
        case 1: pp->setSrcGroupId(string2long(value)); return true;
        case 3: pp->setSucGroupId(i,string2long(value)); return true;
        case 5: pp->setPreGroupId(string2long(value)); return true;
        case 6: pp->setPreNodeSet(string2bool(value)); return true;
        default: return false;
    }
}

const char *MyNotifyResponseDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        NULL,
        NULL,
        "NodeHandle",
        NULL,
        "NodeHandle",
        NULL,
        NULL,
    };
    return (field>=0 && field<7) ? fieldStructNames[field] : NULL;
}

void *MyNotifyResponseDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyNotifyResponse *pp = (MyNotifyResponse *)object; (void)pp;
    switch (field) {
        case 2: return (void *)(&pp->getSucNode(i)); break;
        case 4: return (void *)(&pp->getPreNode()); break;
        default: return NULL;
    }
}

Register_Class(MyJoinCall);

MyJoinCall::MyJoinCall(const char *name, int kind) : BaseCallMessage(name,kind)
{
    this->groupId_var = 0;
}

MyJoinCall::MyJoinCall(const MyJoinCall& other) : BaseCallMessage()
{
    setName(other.getName());
    operator=(other);
}

MyJoinCall::~MyJoinCall()
{
}

MyJoinCall& MyJoinCall::operator=(const MyJoinCall& other)
{
    if (this==&other) return *this;
    BaseCallMessage::operator=(other);
    this->groupId_var = other.groupId_var;
    return *this;
}

void MyJoinCall::parsimPack(cCommBuffer *b)
{
    BaseCallMessage::parsimPack(b);
    doPacking(b,this->groupId_var);
}

void MyJoinCall::parsimUnpack(cCommBuffer *b)
{
    BaseCallMessage::parsimUnpack(b);
    doUnpacking(b,this->groupId_var);
}

int MyJoinCall::getGroupId() const
{
    return groupId_var;
}

void MyJoinCall::setGroupId(int groupId_var)
{
    this->groupId_var = groupId_var;
}

class MyJoinCallDescriptor : public cClassDescriptor
{
  public:
    MyJoinCallDescriptor();
    virtual ~MyJoinCallDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyJoinCallDescriptor);

MyJoinCallDescriptor::MyJoinCallDescriptor() : cClassDescriptor("MyJoinCall", "BaseCallMessage")
{
}

MyJoinCallDescriptor::~MyJoinCallDescriptor()
{
}

bool MyJoinCallDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyJoinCall *>(obj)!=NULL;
}

const char *MyJoinCallDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

unsigned int MyJoinCallDescriptor::getFieldTypeFlags(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeFlags(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static unsigned int fieldTypeFlags[] = {
        FD_ISEDITABLE,
    };
    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
}

const char *MyJoinCallDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "groupId",
    };
    return (field>=0 && field<1) ? fieldNames[field] : NULL;
}

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

const char *MyJoinCallDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "int",
    };
    return (field>=0 && field<1) ? fieldTypeStrings[field] : NULL;
}

const char *MyJoinCallDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyJoinCallDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyJoinCall *pp = (MyJoinCall *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string MyJoinCallDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyJoinCall *pp = (MyJoinCall *)object; (void)pp;
    switch (field) {
        case 0: return long2string(pp->getGroupId());
        default: return "";
    }
}

bool MyJoinCallDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyJoinCall *pp = (MyJoinCall *)object; (void)pp;
    switch (field) {
        case 0: pp->setGroupId(string2long(value)); return true;
        default: return false;
    }
}

const char *MyJoinCallDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        NULL,
    };
    return (field>=0 && field<1) ? fieldStructNames[field] : NULL;
}

void *MyJoinCallDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyJoinCall *pp = (MyJoinCall *)object; (void)pp;
    switch (field) {
        default: return NULL;
    }
}

Register_Class(MyJoinResponse);

MyJoinResponse::MyJoinResponse(const char *name, int kind) : BaseResponseMessage(name,kind)
{
    this->sucNum_var = 0;
    sucNode_arraysize = 0;
    this->sucNode_var = 0;
    sucGroupId_arraysize = 0;
    this->sucGroupId_var = 0;
    this->srcGroupId_var = 0;
    this->preGroupId_var = 0;
}

MyJoinResponse::MyJoinResponse(const MyJoinResponse& other) : BaseResponseMessage()
{
    setName(other.getName());
    sucNode_arraysize = 0;
    this->sucNode_var = 0;
    sucGroupId_arraysize = 0;
    this->sucGroupId_var = 0;
    operator=(other);
}

MyJoinResponse::~MyJoinResponse()
{
    delete [] sucNode_var;
    delete [] sucGroupId_var;
}

MyJoinResponse& MyJoinResponse::operator=(const MyJoinResponse& other)
{
    if (this==&other) return *this;
    BaseResponseMessage::operator=(other);
    this->sucNum_var = other.sucNum_var;
    delete [] this->sucNode_var;
    this->sucNode_var = (other.sucNode_arraysize==0) ? NULL : new ::NodeHandle[other.sucNode_arraysize];
    sucNode_arraysize = other.sucNode_arraysize;
    for (unsigned int i=0; i<sucNode_arraysize; i++)
        this->sucNode_var[i] = other.sucNode_var[i];
    delete [] this->sucGroupId_var;
    this->sucGroupId_var = (other.sucGroupId_arraysize==0) ? NULL : new int[other.sucGroupId_arraysize];
    sucGroupId_arraysize = other.sucGroupId_arraysize;
    for (unsigned int i=0; i<sucGroupId_arraysize; i++)
        this->sucGroupId_var[i] = other.sucGroupId_var[i];
    this->preNode_var = other.preNode_var;
    this->srcGroupId_var = other.srcGroupId_var;
    this->preGroupId_var = other.preGroupId_var;
    return *this;
}

void MyJoinResponse::parsimPack(cCommBuffer *b)
{
    BaseResponseMessage::parsimPack(b);
    doPacking(b,this->sucNum_var);
    b->pack(sucNode_arraysize);
    doPacking(b,this->sucNode_var,sucNode_arraysize);
    b->pack(sucGroupId_arraysize);
    doPacking(b,this->sucGroupId_var,sucGroupId_arraysize);
    doPacking(b,this->preNode_var);
    doPacking(b,this->srcGroupId_var);
    doPacking(b,this->preGroupId_var);
}

void MyJoinResponse::parsimUnpack(cCommBuffer *b)
{
    BaseResponseMessage::parsimUnpack(b);
    doUnpacking(b,this->sucNum_var);
    delete [] this->sucNode_var;
    b->unpack(sucNode_arraysize);
    if (sucNode_arraysize==0) {
        this->sucNode_var = 0;
    } else {
        this->sucNode_var = new ::NodeHandle[sucNode_arraysize];
        doUnpacking(b,this->sucNode_var,sucNode_arraysize);
    }
    delete [] this->sucGroupId_var;
    b->unpack(sucGroupId_arraysize);
    if (sucGroupId_arraysize==0) {
        this->sucGroupId_var = 0;
    } else {
        this->sucGroupId_var = new int[sucGroupId_arraysize];
        doUnpacking(b,this->sucGroupId_var,sucGroupId_arraysize);
    }
    doUnpacking(b,this->preNode_var);
    doUnpacking(b,this->srcGroupId_var);
    doUnpacking(b,this->preGroupId_var);
}

int MyJoinResponse::getSucNum() const
{
    return sucNum_var;
}

void MyJoinResponse::setSucNum(int sucNum_var)
{
    this->sucNum_var = sucNum_var;
}

void MyJoinResponse::setSucNodeArraySize(unsigned int size)
{
    ::NodeHandle *sucNode_var2 = (size==0) ? NULL : new ::NodeHandle[size];
    unsigned int sz = sucNode_arraysize < size ? sucNode_arraysize : size;
    for (unsigned int i=0; i<sz; i++)
        sucNode_var2[i] = this->sucNode_var[i];
    sucNode_arraysize = size;
    delete [] this->sucNode_var;
    this->sucNode_var = sucNode_var2;
}

unsigned int MyJoinResponse::getSucNodeArraySize() const
{
    return sucNode_arraysize;
}

NodeHandle& MyJoinResponse::getSucNode(unsigned int k)
{
    if (k>=sucNode_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucNode_arraysize, k);
    return sucNode_var[k];
}

void MyJoinResponse::setSucNode(unsigned int k, const NodeHandle& sucNode_var)
{
    if (k>=sucNode_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucNode_arraysize, k);
    this->sucNode_var[k]=sucNode_var;
}

void MyJoinResponse::setSucGroupIdArraySize(unsigned int size)
{
    int *sucGroupId_var2 = (size==0) ? NULL : new int[size];
    unsigned int sz = sucGroupId_arraysize < size ? sucGroupId_arraysize : size;
    for (unsigned int i=0; i<sz; i++)
        sucGroupId_var2[i] = this->sucGroupId_var[i];
    for (unsigned int i=sz; i<size; i++)
        sucGroupId_var2[i] = 0;
    sucGroupId_arraysize = size;
    delete [] this->sucGroupId_var;
    this->sucGroupId_var = sucGroupId_var2;
}

unsigned int MyJoinResponse::getSucGroupIdArraySize() const
{
    return sucGroupId_arraysize;
}

int MyJoinResponse::getSucGroupId(unsigned int k) const
{
    if (k>=sucGroupId_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucGroupId_arraysize, k);
    return sucGroupId_var[k];
}

void MyJoinResponse::setSucGroupId(unsigned int k, int sucGroupId_var)
{
    if (k>=sucGroupId_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucGroupId_arraysize, k);
    this->sucGroupId_var[k]=sucGroupId_var;
}

NodeHandle& MyJoinResponse::getPreNode()
{
    return preNode_var;
}

void MyJoinResponse::setPreNode(const NodeHandle& preNode_var)
{
    this->preNode_var = preNode_var;
}

int MyJoinResponse::getSrcGroupId() const
{
    return srcGroupId_var;
}

void MyJoinResponse::setSrcGroupId(int srcGroupId_var)
{
    this->srcGroupId_var = srcGroupId_var;
}

int MyJoinResponse::getPreGroupId() const
{
    return preGroupId_var;
}

void MyJoinResponse::setPreGroupId(int preGroupId_var)
{
    this->preGroupId_var = preGroupId_var;
}

class MyJoinResponseDescriptor : public cClassDescriptor
{
  public:
    MyJoinResponseDescriptor();
    virtual ~MyJoinResponseDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyJoinResponseDescriptor);

MyJoinResponseDescriptor::MyJoinResponseDescriptor() : cClassDescriptor("MyJoinResponse", "BaseResponseMessage")
{
}

MyJoinResponseDescriptor::~MyJoinResponseDescriptor()
{
}

bool MyJoinResponseDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyJoinResponse *>(obj)!=NULL;
}

const char *MyJoinResponseDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

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

const char *MyJoinResponseDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "sucNum",
        "sucNode",
        "sucGroupId",
        "preNode",
        "srcGroupId",
        "preGroupId",
    };
    return (field>=0 && field<6) ? fieldNames[field] : NULL;
}

int MyJoinResponseDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucNum")==0) return base+0;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucNode")==0) return base+1;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucGroupId")==0) return base+2;
    if (fieldName[0]=='p' && strcmp(fieldName, "preNode")==0) return base+3;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcGroupId")==0) return base+4;
    if (fieldName[0]=='p' && strcmp(fieldName, "preGroupId")==0) return base+5;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyJoinResponseDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "int",
        "NodeHandle",
        "int",
        "NodeHandle",
        "int",
        "int",
    };
    return (field>=0 && field<6) ? fieldTypeStrings[field] : NULL;
}

const char *MyJoinResponseDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyJoinResponseDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyJoinResponse *pp = (MyJoinResponse *)object; (void)pp;
    switch (field) {
        case 1: return pp->getSucNodeArraySize();
        case 2: return pp->getSucGroupIdArraySize();
        default: return 0;
    }
}

std::string MyJoinResponseDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyJoinResponse *pp = (MyJoinResponse *)object; (void)pp;
    switch (field) {
        case 0: return long2string(pp->getSucNum());
        case 1: {std::stringstream out; out << pp->getSucNode(i); return out.str();}
        case 2: return long2string(pp->getSucGroupId(i));
        case 3: {std::stringstream out; out << pp->getPreNode(); return out.str();}
        case 4: return long2string(pp->getSrcGroupId());
        case 5: return long2string(pp->getPreGroupId());
        default: return "";
    }
}

bool MyJoinResponseDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyJoinResponse *pp = (MyJoinResponse *)object; (void)pp;
    switch (field) {
        case 0: pp->setSucNum(string2long(value)); return true;
        case 2: pp->setSucGroupId(i,string2long(value)); return true;
        case 4: pp->setSrcGroupId(string2long(value)); return true;
        case 5: pp->setPreGroupId(string2long(value)); return true;
        default: return false;
    }
}

const char *MyJoinResponseDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        NULL,
        "NodeHandle",
        NULL,
        "NodeHandle",
        NULL,
        NULL,
    };
    return (field>=0 && field<6) ? fieldStructNames[field] : NULL;
}

void *MyJoinResponseDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyJoinResponse *pp = (MyJoinResponse *)object; (void)pp;
    switch (field) {
        case 1: return (void *)(&pp->getSucNode(i)); break;
        case 3: return (void *)(&pp->getPreNode()); break;
        default: return NULL;
    }
}

Register_Class(MyStabilizeCall);

MyStabilizeCall::MyStabilizeCall(const char *name, int kind) : BaseCallMessage(name,kind)
{
}

MyStabilizeCall::MyStabilizeCall(const MyStabilizeCall& other) : BaseCallMessage()
{
    setName(other.getName());
    operator=(other);
}

MyStabilizeCall::~MyStabilizeCall()
{
}

MyStabilizeCall& MyStabilizeCall::operator=(const MyStabilizeCall& other)
{
    if (this==&other) return *this;
    BaseCallMessage::operator=(other);
    return *this;
}

void MyStabilizeCall::parsimPack(cCommBuffer *b)
{
    BaseCallMessage::parsimPack(b);
}

void MyStabilizeCall::parsimUnpack(cCommBuffer *b)
{
    BaseCallMessage::parsimUnpack(b);
}

class MyStabilizeCallDescriptor : public cClassDescriptor
{
  public:
    MyStabilizeCallDescriptor();
    virtual ~MyStabilizeCallDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyStabilizeCallDescriptor);

MyStabilizeCallDescriptor::MyStabilizeCallDescriptor() : cClassDescriptor("MyStabilizeCall", "BaseCallMessage")
{
}

MyStabilizeCallDescriptor::~MyStabilizeCallDescriptor()
{
}

bool MyStabilizeCallDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyStabilizeCall *>(obj)!=NULL;
}

const char *MyStabilizeCallDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

unsigned int MyStabilizeCallDescriptor::getFieldTypeFlags(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeFlags(object, field);
        field -= basedesc->getFieldCount(object);
    }
    return 0;
}

const char *MyStabilizeCallDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    return NULL;
}

int MyStabilizeCallDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyStabilizeCallDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    return NULL;
}

const char *MyStabilizeCallDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyStabilizeCallDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyStabilizeCall *pp = (MyStabilizeCall *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string MyStabilizeCallDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyStabilizeCall *pp = (MyStabilizeCall *)object; (void)pp;
    switch (field) {
        default: return "";
    }
}

bool MyStabilizeCallDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyStabilizeCall *pp = (MyStabilizeCall *)object; (void)pp;
    switch (field) {
        default: return false;
    }
}

const char *MyStabilizeCallDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    return NULL;
}

void *MyStabilizeCallDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyStabilizeCall *pp = (MyStabilizeCall *)object; (void)pp;
    switch (field) {
        default: return NULL;
    }
}

Register_Class(MyStabilizeResponse);

MyStabilizeResponse::MyStabilizeResponse(const char *name, int kind) : BaseResponseMessage(name,kind)
{
    this->srcGroupId_var = 0;
    this->preGroupId_var = 0;
}

MyStabilizeResponse::MyStabilizeResponse(const MyStabilizeResponse& other) : BaseResponseMessage()
{
    setName(other.getName());
    operator=(other);
}

MyStabilizeResponse::~MyStabilizeResponse()
{
}

MyStabilizeResponse& MyStabilizeResponse::operator=(const MyStabilizeResponse& other)
{
    if (this==&other) return *this;
    BaseResponseMessage::operator=(other);
    this->preNode_var = other.preNode_var;
    this->srcGroupId_var = other.srcGroupId_var;
    this->preGroupId_var = other.preGroupId_var;
    return *this;
}

void MyStabilizeResponse::parsimPack(cCommBuffer *b)
{
    BaseResponseMessage::parsimPack(b);
    doPacking(b,this->preNode_var);
    doPacking(b,this->srcGroupId_var);
    doPacking(b,this->preGroupId_var);
}

void MyStabilizeResponse::parsimUnpack(cCommBuffer *b)
{
    BaseResponseMessage::parsimUnpack(b);
    doUnpacking(b,this->preNode_var);
    doUnpacking(b,this->srcGroupId_var);
    doUnpacking(b,this->preGroupId_var);
}

NodeHandle& MyStabilizeResponse::getPreNode()
{
    return preNode_var;
}

void MyStabilizeResponse::setPreNode(const NodeHandle& preNode_var)
{
    this->preNode_var = preNode_var;
}

int MyStabilizeResponse::getSrcGroupId() const
{
    return srcGroupId_var;
}

void MyStabilizeResponse::setSrcGroupId(int srcGroupId_var)
{
    this->srcGroupId_var = srcGroupId_var;
}

int MyStabilizeResponse::getPreGroupId() const
{
    return preGroupId_var;
}

void MyStabilizeResponse::setPreGroupId(int preGroupId_var)
{
    this->preGroupId_var = preGroupId_var;
}

class MyStabilizeResponseDescriptor : public cClassDescriptor
{
  public:
    MyStabilizeResponseDescriptor();
    virtual ~MyStabilizeResponseDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyStabilizeResponseDescriptor);

MyStabilizeResponseDescriptor::MyStabilizeResponseDescriptor() : cClassDescriptor("MyStabilizeResponse", "BaseResponseMessage")
{
}

MyStabilizeResponseDescriptor::~MyStabilizeResponseDescriptor()
{
}

bool MyStabilizeResponseDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyStabilizeResponse *>(obj)!=NULL;
}

const char *MyStabilizeResponseDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

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

const char *MyStabilizeResponseDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "preNode",
        "srcGroupId",
        "preGroupId",
    };
    return (field>=0 && field<3) ? fieldNames[field] : NULL;
}

int MyStabilizeResponseDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='p' && strcmp(fieldName, "preNode")==0) return base+0;
    if (fieldName[0]=='s' && strcmp(fieldName, "srcGroupId")==0) return base+1;
    if (fieldName[0]=='p' && strcmp(fieldName, "preGroupId")==0) return base+2;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyStabilizeResponseDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "NodeHandle",
        "int",
        "int",
    };
    return (field>=0 && field<3) ? fieldTypeStrings[field] : NULL;
}

const char *MyStabilizeResponseDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyStabilizeResponseDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyStabilizeResponse *pp = (MyStabilizeResponse *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string MyStabilizeResponseDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyStabilizeResponse *pp = (MyStabilizeResponse *)object; (void)pp;
    switch (field) {
        case 0: {std::stringstream out; out << pp->getPreNode(); return out.str();}
        case 1: return long2string(pp->getSrcGroupId());
        case 2: return long2string(pp->getPreGroupId());
        default: return "";
    }
}

bool MyStabilizeResponseDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyStabilizeResponse *pp = (MyStabilizeResponse *)object; (void)pp;
    switch (field) {
        case 1: pp->setSrcGroupId(string2long(value)); return true;
        case 2: pp->setPreGroupId(string2long(value)); return true;
        default: return false;
    }
}

const char *MyStabilizeResponseDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        "NodeHandle",
        NULL,
        NULL,
    };
    return (field>=0 && field<3) ? fieldStructNames[field] : NULL;
}

void *MyStabilizeResponseDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyStabilizeResponse *pp = (MyStabilizeResponse *)object; (void)pp;
    switch (field) {
        case 0: return (void *)(&pp->getPreNode()); break;
        default: return NULL;
    }
}

Register_Class(MyFixfingersCall);

MyFixfingersCall::MyFixfingersCall(const char *name, int kind) : BaseCallMessage(name,kind)
{
    this->finger_var = 0;
    this->groupId_var = 0;
}

MyFixfingersCall::MyFixfingersCall(const MyFixfingersCall& other) : BaseCallMessage()
{
    setName(other.getName());
    operator=(other);
}

MyFixfingersCall::~MyFixfingersCall()
{
}

MyFixfingersCall& MyFixfingersCall::operator=(const MyFixfingersCall& other)
{
    if (this==&other) return *this;
    BaseCallMessage::operator=(other);
    this->finger_var = other.finger_var;
    this->groupId_var = other.groupId_var;
    return *this;
}

void MyFixfingersCall::parsimPack(cCommBuffer *b)
{
    BaseCallMessage::parsimPack(b);
    doPacking(b,this->finger_var);
    doPacking(b,this->groupId_var);
}

void MyFixfingersCall::parsimUnpack(cCommBuffer *b)
{
    BaseCallMessage::parsimUnpack(b);
    doUnpacking(b,this->finger_var);
    doUnpacking(b,this->groupId_var);
}

unsigned int MyFixfingersCall::getFinger() const
{
    return finger_var;
}

void MyFixfingersCall::setFinger(unsigned int finger_var)
{
    this->finger_var = finger_var;
}

int MyFixfingersCall::getGroupId() const
{
    return groupId_var;
}

void MyFixfingersCall::setGroupId(int groupId_var)
{
    this->groupId_var = groupId_var;
}

class MyFixfingersCallDescriptor : public cClassDescriptor
{
  public:
    MyFixfingersCallDescriptor();
    virtual ~MyFixfingersCallDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyFixfingersCallDescriptor);

MyFixfingersCallDescriptor::MyFixfingersCallDescriptor() : cClassDescriptor("MyFixfingersCall", "BaseCallMessage")
{
}

MyFixfingersCallDescriptor::~MyFixfingersCallDescriptor()
{
}

bool MyFixfingersCallDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyFixfingersCall *>(obj)!=NULL;
}

const char *MyFixfingersCallDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

unsigned int MyFixfingersCallDescriptor::getFieldTypeFlags(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeFlags(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static unsigned int fieldTypeFlags[] = {
        FD_ISEDITABLE,
        FD_ISEDITABLE,
    };
    return (field>=0 && field<2) ? fieldTypeFlags[field] : 0;
}

const char *MyFixfingersCallDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "finger",
        "groupId",
    };
    return (field>=0 && field<2) ? fieldNames[field] : NULL;
}

int MyFixfingersCallDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "finger")==0) return base+0;
    if (fieldName[0]=='g' && strcmp(fieldName, "groupId")==0) return base+1;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyFixfingersCallDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "unsigned int",
        "int",
    };
    return (field>=0 && field<2) ? fieldTypeStrings[field] : NULL;
}

const char *MyFixfingersCallDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyFixfingersCallDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyFixfingersCall *pp = (MyFixfingersCall *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string MyFixfingersCallDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyFixfingersCall *pp = (MyFixfingersCall *)object; (void)pp;
    switch (field) {
        case 0: return ulong2string(pp->getFinger());
        case 1: return long2string(pp->getGroupId());
        default: return "";
    }
}

bool MyFixfingersCallDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyFixfingersCall *pp = (MyFixfingersCall *)object; (void)pp;
    switch (field) {
        case 0: pp->setFinger(string2ulong(value)); return true;
        case 1: pp->setGroupId(string2long(value)); return true;
        default: return false;
    }
}

const char *MyFixfingersCallDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        NULL,
        NULL,
    };
    return (field>=0 && field<2) ? fieldStructNames[field] : NULL;
}

void *MyFixfingersCallDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyFixfingersCall *pp = (MyFixfingersCall *)object; (void)pp;
    switch (field) {
        default: return NULL;
    }
}

Register_Class(MyFixfingersResponse);

MyFixfingersResponse::MyFixfingersResponse(const char *name, int kind) : BaseResponseMessage(name,kind)
{
    this->finger_var = 0;
    sucNode_arraysize = 0;
    this->sucNode_var = 0;
    sucGroupId_arraysize = 0;
    this->sucGroupId_var = 0;
}

MyFixfingersResponse::MyFixfingersResponse(const MyFixfingersResponse& other) : BaseResponseMessage()
{
    setName(other.getName());
    sucNode_arraysize = 0;
    this->sucNode_var = 0;
    sucGroupId_arraysize = 0;
    this->sucGroupId_var = 0;
    operator=(other);
}

MyFixfingersResponse::~MyFixfingersResponse()
{
    delete [] sucNode_var;
    delete [] sucGroupId_var;
}

MyFixfingersResponse& MyFixfingersResponse::operator=(const MyFixfingersResponse& other)
{
    if (this==&other) return *this;
    BaseResponseMessage::operator=(other);
    this->finger_var = other.finger_var;
    delete [] this->sucNode_var;
    this->sucNode_var = (other.sucNode_arraysize==0) ? NULL : new ::NodeHandle[other.sucNode_arraysize];
    sucNode_arraysize = other.sucNode_arraysize;
    for (unsigned int i=0; i<sucNode_arraysize; i++)
        this->sucNode_var[i] = other.sucNode_var[i];
    delete [] this->sucGroupId_var;
    this->sucGroupId_var = (other.sucGroupId_arraysize==0) ? NULL : new int[other.sucGroupId_arraysize];
    sucGroupId_arraysize = other.sucGroupId_arraysize;
    for (unsigned int i=0; i<sucGroupId_arraysize; i++)
        this->sucGroupId_var[i] = other.sucGroupId_var[i];
    return *this;
}

void MyFixfingersResponse::parsimPack(cCommBuffer *b)
{
    BaseResponseMessage::parsimPack(b);
    doPacking(b,this->finger_var);
    b->pack(sucNode_arraysize);
    doPacking(b,this->sucNode_var,sucNode_arraysize);
    b->pack(sucGroupId_arraysize);
    doPacking(b,this->sucGroupId_var,sucGroupId_arraysize);
}

void MyFixfingersResponse::parsimUnpack(cCommBuffer *b)
{
    BaseResponseMessage::parsimUnpack(b);
    doUnpacking(b,this->finger_var);
    delete [] this->sucNode_var;
    b->unpack(sucNode_arraysize);
    if (sucNode_arraysize==0) {
        this->sucNode_var = 0;
    } else {
        this->sucNode_var = new ::NodeHandle[sucNode_arraysize];
        doUnpacking(b,this->sucNode_var,sucNode_arraysize);
    }
    delete [] this->sucGroupId_var;
    b->unpack(sucGroupId_arraysize);
    if (sucGroupId_arraysize==0) {
        this->sucGroupId_var = 0;
    } else {
        this->sucGroupId_var = new int[sucGroupId_arraysize];
        doUnpacking(b,this->sucGroupId_var,sucGroupId_arraysize);
    }
}

int MyFixfingersResponse::getFinger() const
{
    return finger_var;
}

void MyFixfingersResponse::setFinger(int finger_var)
{
    this->finger_var = finger_var;
}

void MyFixfingersResponse::setSucNodeArraySize(unsigned int size)
{
    ::NodeHandle *sucNode_var2 = (size==0) ? NULL : new ::NodeHandle[size];
    unsigned int sz = sucNode_arraysize < size ? sucNode_arraysize : size;
    for (unsigned int i=0; i<sz; i++)
        sucNode_var2[i] = this->sucNode_var[i];
    sucNode_arraysize = size;
    delete [] this->sucNode_var;
    this->sucNode_var = sucNode_var2;
}

unsigned int MyFixfingersResponse::getSucNodeArraySize() const
{
    return sucNode_arraysize;
}

NodeHandle& MyFixfingersResponse::getSucNode(unsigned int k)
{
    if (k>=sucNode_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucNode_arraysize, k);
    return sucNode_var[k];
}

void MyFixfingersResponse::setSucNode(unsigned int k, const NodeHandle& sucNode_var)
{
    if (k>=sucNode_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucNode_arraysize, k);
    this->sucNode_var[k]=sucNode_var;
}

void MyFixfingersResponse::setSucGroupIdArraySize(unsigned int size)
{
    int *sucGroupId_var2 = (size==0) ? NULL : new int[size];
    unsigned int sz = sucGroupId_arraysize < size ? sucGroupId_arraysize : size;
    for (unsigned int i=0; i<sz; i++)
        sucGroupId_var2[i] = this->sucGroupId_var[i];
    for (unsigned int i=sz; i<size; i++)
        sucGroupId_var2[i] = 0;
    sucGroupId_arraysize = size;
    delete [] this->sucGroupId_var;
    this->sucGroupId_var = sucGroupId_var2;
}

unsigned int MyFixfingersResponse::getSucGroupIdArraySize() const
{
    return sucGroupId_arraysize;
}

int MyFixfingersResponse::getSucGroupId(unsigned int k) const
{
    if (k>=sucGroupId_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucGroupId_arraysize, k);
    return sucGroupId_var[k];
}

void MyFixfingersResponse::setSucGroupId(unsigned int k, int sucGroupId_var)
{
    if (k>=sucGroupId_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucGroupId_arraysize, k);
    this->sucGroupId_var[k]=sucGroupId_var;
}

class MyFixfingersResponseDescriptor : public cClassDescriptor
{
  public:
    MyFixfingersResponseDescriptor();
    virtual ~MyFixfingersResponseDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyFixfingersResponseDescriptor);

MyFixfingersResponseDescriptor::MyFixfingersResponseDescriptor() : cClassDescriptor("MyFixfingersResponse", "BaseResponseMessage")
{
}

MyFixfingersResponseDescriptor::~MyFixfingersResponseDescriptor()
{
}

bool MyFixfingersResponseDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyFixfingersResponse *>(obj)!=NULL;
}

const char *MyFixfingersResponseDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

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

const char *MyFixfingersResponseDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "finger",
        "sucNode",
        "sucGroupId",
    };
    return (field>=0 && field<3) ? fieldNames[field] : NULL;
}

int MyFixfingersResponseDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "finger")==0) return base+0;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucNode")==0) return base+1;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucGroupId")==0) return base+2;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyFixfingersResponseDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "int",
        "NodeHandle",
        "int",
    };
    return (field>=0 && field<3) ? fieldTypeStrings[field] : NULL;
}

const char *MyFixfingersResponseDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyFixfingersResponseDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyFixfingersResponse *pp = (MyFixfingersResponse *)object; (void)pp;
    switch (field) {
        case 1: return pp->getSucNodeArraySize();
        case 2: return pp->getSucGroupIdArraySize();
        default: return 0;
    }
}

std::string MyFixfingersResponseDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyFixfingersResponse *pp = (MyFixfingersResponse *)object; (void)pp;
    switch (field) {
        case 0: return long2string(pp->getFinger());
        case 1: {std::stringstream out; out << pp->getSucNode(i); return out.str();}
        case 2: return long2string(pp->getSucGroupId(i));
        default: return "";
    }
}

bool MyFixfingersResponseDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyFixfingersResponse *pp = (MyFixfingersResponse *)object; (void)pp;
    switch (field) {
        case 0: pp->setFinger(string2long(value)); return true;
        case 2: pp->setSucGroupId(i,string2long(value)); return true;
        default: return false;
    }
}

const char *MyFixfingersResponseDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        NULL,
        "NodeHandle",
        NULL,
    };
    return (field>=0 && field<3) ? fieldStructNames[field] : NULL;
}

void *MyFixfingersResponseDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyFixfingersResponse *pp = (MyFixfingersResponse *)object; (void)pp;
    switch (field) {
        case 1: return (void *)(&pp->getSucNode(i)); break;
        default: return NULL;
    }
}

Register_Class(MyFindGroupMemberMessage);

MyFindGroupMemberMessage::MyFindGroupMemberMessage(const char *name, int kind) : MyChordMessage(name,kind)
{
    this->finger_var = 0;
    this->groupId_var = 0;
    this->hopCount_var = 0;
}

MyFindGroupMemberMessage::MyFindGroupMemberMessage(const MyFindGroupMemberMessage& other) : MyChordMessage()
{
    setName(other.getName());
    operator=(other);
}

MyFindGroupMemberMessage::~MyFindGroupMemberMessage()
{
}

MyFindGroupMemberMessage& MyFindGroupMemberMessage::operator=(const MyFindGroupMemberMessage& other)
{
    if (this==&other) return *this;
    MyChordMessage::operator=(other);
    this->finger_var = other.finger_var;
    this->originalSrcNode_var = other.originalSrcNode_var;
    this->keyLimit_var = other.keyLimit_var;
    this->groupId_var = other.groupId_var;
    this->hopCount_var = other.hopCount_var;
    return *this;
}

void MyFindGroupMemberMessage::parsimPack(cCommBuffer *b)
{
    MyChordMessage::parsimPack(b);
    doPacking(b,this->finger_var);
    doPacking(b,this->originalSrcNode_var);
    doPacking(b,this->keyLimit_var);
    doPacking(b,this->groupId_var);
    doPacking(b,this->hopCount_var);
}

void MyFindGroupMemberMessage::parsimUnpack(cCommBuffer *b)
{
    MyChordMessage::parsimUnpack(b);
    doUnpacking(b,this->finger_var);
    doUnpacking(b,this->originalSrcNode_var);
    doUnpacking(b,this->keyLimit_var);
    doUnpacking(b,this->groupId_var);
    doUnpacking(b,this->hopCount_var);
}

int MyFindGroupMemberMessage::getFinger() const
{
    return finger_var;
}

void MyFindGroupMemberMessage::setFinger(int finger_var)
{
    this->finger_var = finger_var;
}

NodeHandle& MyFindGroupMemberMessage::getOriginalSrcNode()
{
    return originalSrcNode_var;
}

void MyFindGroupMemberMessage::setOriginalSrcNode(const NodeHandle& originalSrcNode_var)
{
    this->originalSrcNode_var = originalSrcNode_var;
}

OverlayKey& MyFindGroupMemberMessage::getKeyLimit()
{
    return keyLimit_var;
}

void MyFindGroupMemberMessage::setKeyLimit(const OverlayKey& keyLimit_var)
{
    this->keyLimit_var = keyLimit_var;
}

int MyFindGroupMemberMessage::getGroupId() const
{
    return groupId_var;
}

void MyFindGroupMemberMessage::setGroupId(int groupId_var)
{
    this->groupId_var = groupId_var;
}

int MyFindGroupMemberMessage::getHopCount() const
{
    return hopCount_var;
}

void MyFindGroupMemberMessage::setHopCount(int hopCount_var)
{
    this->hopCount_var = hopCount_var;
}

class MyFindGroupMemberMessageDescriptor : public cClassDescriptor
{
  public:
    MyFindGroupMemberMessageDescriptor();
    virtual ~MyFindGroupMemberMessageDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyFindGroupMemberMessageDescriptor);

MyFindGroupMemberMessageDescriptor::MyFindGroupMemberMessageDescriptor() : cClassDescriptor("MyFindGroupMemberMessage", "MyChordMessage")
{
}

MyFindGroupMemberMessageDescriptor::~MyFindGroupMemberMessageDescriptor()
{
}

bool MyFindGroupMemberMessageDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyFindGroupMemberMessage *>(obj)!=NULL;
}

const char *MyFindGroupMemberMessageDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

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

const char *MyFindGroupMemberMessageDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "finger",
        "originalSrcNode",
        "keyLimit",
        "groupId",
        "hopCount",
    };
    return (field>=0 && field<5) ? fieldNames[field] : NULL;
}

int MyFindGroupMemberMessageDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "finger")==0) return base+0;
    if (fieldName[0]=='o' && strcmp(fieldName, "originalSrcNode")==0) return base+1;
    if (fieldName[0]=='k' && strcmp(fieldName, "keyLimit")==0) return base+2;
    if (fieldName[0]=='g' && strcmp(fieldName, "groupId")==0) return base+3;
    if (fieldName[0]=='h' && strcmp(fieldName, "hopCount")==0) return base+4;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyFindGroupMemberMessageDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "int",
        "NodeHandle",
        "OverlayKey",
        "int",
        "int",
    };
    return (field>=0 && field<5) ? fieldTypeStrings[field] : NULL;
}

const char *MyFindGroupMemberMessageDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyFindGroupMemberMessageDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyFindGroupMemberMessage *pp = (MyFindGroupMemberMessage *)object; (void)pp;
    switch (field) {
        default: return 0;
    }
}

std::string MyFindGroupMemberMessageDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyFindGroupMemberMessage *pp = (MyFindGroupMemberMessage *)object; (void)pp;
    switch (field) {
        case 0: return long2string(pp->getFinger());
        case 1: {std::stringstream out; out << pp->getOriginalSrcNode(); return out.str();}
        case 2: {std::stringstream out; out << pp->getKeyLimit(); return out.str();}
        case 3: return long2string(pp->getGroupId());
        case 4: return long2string(pp->getHopCount());
        default: return "";
    }
}

bool MyFindGroupMemberMessageDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyFindGroupMemberMessage *pp = (MyFindGroupMemberMessage *)object; (void)pp;
    switch (field) {
        case 0: pp->setFinger(string2long(value)); return true;
        case 3: pp->setGroupId(string2long(value)); return true;
        case 4: pp->setHopCount(string2long(value)); return true;
        default: return false;
    }
}

const char *MyFindGroupMemberMessageDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        NULL,
        "NodeHandle",
        "OverlayKey",
        NULL,
        NULL,
    };
    return (field>=0 && field<5) ? fieldStructNames[field] : NULL;
}

void *MyFindGroupMemberMessageDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyFindGroupMemberMessage *pp = (MyFindGroupMemberMessage *)object; (void)pp;
    switch (field) {
        case 1: return (void *)(&pp->getOriginalSrcNode()); break;
        case 2: return (void *)(&pp->getKeyLimit()); break;
        default: return NULL;
    }
}

Register_Class(MyFindGroupMemberReply);

MyFindGroupMemberReply::MyFindGroupMemberReply(const char *name, int kind) : MyChordMessage(name,kind)
{
    this->finger_var = 0;
    sucNode_arraysize = 0;
    this->sucNode_var = 0;
    this->groupId_var = 0;
}

MyFindGroupMemberReply::MyFindGroupMemberReply(const MyFindGroupMemberReply& other) : MyChordMessage()
{
    setName(other.getName());
    sucNode_arraysize = 0;
    this->sucNode_var = 0;
    operator=(other);
}

MyFindGroupMemberReply::~MyFindGroupMemberReply()
{
    delete [] sucNode_var;
}

MyFindGroupMemberReply& MyFindGroupMemberReply::operator=(const MyFindGroupMemberReply& other)
{
    if (this==&other) return *this;
    MyChordMessage::operator=(other);
    this->finger_var = other.finger_var;
    delete [] this->sucNode_var;
    this->sucNode_var = (other.sucNode_arraysize==0) ? NULL : new ::NodeHandle[other.sucNode_arraysize];
    sucNode_arraysize = other.sucNode_arraysize;
    for (unsigned int i=0; i<sucNode_arraysize; i++)
        this->sucNode_var[i] = other.sucNode_var[i];
    this->groupId_var = other.groupId_var;
    return *this;
}

void MyFindGroupMemberReply::parsimPack(cCommBuffer *b)
{
    MyChordMessage::parsimPack(b);
    doPacking(b,this->finger_var);
    b->pack(sucNode_arraysize);
    doPacking(b,this->sucNode_var,sucNode_arraysize);
    doPacking(b,this->groupId_var);
}

void MyFindGroupMemberReply::parsimUnpack(cCommBuffer *b)
{
    MyChordMessage::parsimUnpack(b);
    doUnpacking(b,this->finger_var);
    delete [] this->sucNode_var;
    b->unpack(sucNode_arraysize);
    if (sucNode_arraysize==0) {
        this->sucNode_var = 0;
    } else {
        this->sucNode_var = new ::NodeHandle[sucNode_arraysize];
        doUnpacking(b,this->sucNode_var,sucNode_arraysize);
    }
    doUnpacking(b,this->groupId_var);
}

int MyFindGroupMemberReply::getFinger() const
{
    return finger_var;
}

void MyFindGroupMemberReply::setFinger(int finger_var)
{
    this->finger_var = finger_var;
}

void MyFindGroupMemberReply::setSucNodeArraySize(unsigned int size)
{
    ::NodeHandle *sucNode_var2 = (size==0) ? NULL : new ::NodeHandle[size];
    unsigned int sz = sucNode_arraysize < size ? sucNode_arraysize : size;
    for (unsigned int i=0; i<sz; i++)
        sucNode_var2[i] = this->sucNode_var[i];
    sucNode_arraysize = size;
    delete [] this->sucNode_var;
    this->sucNode_var = sucNode_var2;
}

unsigned int MyFindGroupMemberReply::getSucNodeArraySize() const
{
    return sucNode_arraysize;
}

NodeHandle& MyFindGroupMemberReply::getSucNode(unsigned int k)
{
    if (k>=sucNode_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucNode_arraysize, k);
    return sucNode_var[k];
}

void MyFindGroupMemberReply::setSucNode(unsigned int k, const NodeHandle& sucNode_var)
{
    if (k>=sucNode_arraysize) throw cRuntimeError("Array of size %d indexed by %d", sucNode_arraysize, k);
    this->sucNode_var[k]=sucNode_var;
}

int MyFindGroupMemberReply::getGroupId() const
{
    return groupId_var;
}

void MyFindGroupMemberReply::setGroupId(int groupId_var)
{
    this->groupId_var = groupId_var;
}

class MyFindGroupMemberReplyDescriptor : public cClassDescriptor
{
  public:
    MyFindGroupMemberReplyDescriptor();
    virtual ~MyFindGroupMemberReplyDescriptor();

    virtual bool doesSupport(cObject *obj) const;
    virtual const char *getProperty(const char *propertyname) const;
    virtual int getFieldCount(void *object) const;
    virtual const char *getFieldName(void *object, int field) const;
    virtual int findField(void *object, const char *fieldName) const;
    virtual unsigned int getFieldTypeFlags(void *object, int field) const;
    virtual const char *getFieldTypeString(void *object, int field) const;
    virtual const char *getFieldProperty(void *object, int field, const char *propertyname) const;
    virtual int getArraySize(void *object, int field) const;

    virtual std::string getFieldAsString(void *object, int field, int i) const;
    virtual bool setFieldAsString(void *object, int field, int i, const char *value) const;

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

Register_ClassDescriptor(MyFindGroupMemberReplyDescriptor);

MyFindGroupMemberReplyDescriptor::MyFindGroupMemberReplyDescriptor() : cClassDescriptor("MyFindGroupMemberReply", "MyChordMessage")
{
}

MyFindGroupMemberReplyDescriptor::~MyFindGroupMemberReplyDescriptor()
{
}

bool MyFindGroupMemberReplyDescriptor::doesSupport(cObject *obj) const
{
    return dynamic_cast<MyFindGroupMemberReply *>(obj)!=NULL;
}

const char *MyFindGroupMemberReplyDescriptor::getProperty(const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    return basedesc ? basedesc->getProperty(propertyname) : NULL;
}

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

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

const char *MyFindGroupMemberReplyDescriptor::getFieldName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldNames[] = {
        "finger",
        "sucNode",
        "groupId",
    };
    return (field>=0 && field<3) ? fieldNames[field] : NULL;
}

int MyFindGroupMemberReplyDescriptor::findField(void *object, const char *fieldName) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    int base = basedesc ? basedesc->getFieldCount(object) : 0;
    if (fieldName[0]=='f' && strcmp(fieldName, "finger")==0) return base+0;
    if (fieldName[0]=='s' && strcmp(fieldName, "sucNode")==0) return base+1;
    if (fieldName[0]=='g' && strcmp(fieldName, "groupId")==0) return base+2;
    return basedesc ? basedesc->findField(object, fieldName) : -1;
}

const char *MyFindGroupMemberReplyDescriptor::getFieldTypeString(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldTypeString(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldTypeStrings[] = {
        "int",
        "NodeHandle",
        "int",
    };
    return (field>=0 && field<3) ? fieldTypeStrings[field] : NULL;
}

const char *MyFindGroupMemberReplyDescriptor::getFieldProperty(void *object, int field, const char *propertyname) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldProperty(object, field, propertyname);
        field -= basedesc->getFieldCount(object);
    }
    switch (field) {
        default: return NULL;
    }
}

int MyFindGroupMemberReplyDescriptor::getArraySize(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getArraySize(object, field);
        field -= basedesc->getFieldCount(object);
    }
    MyFindGroupMemberReply *pp = (MyFindGroupMemberReply *)object; (void)pp;
    switch (field) {
        case 1: return pp->getSucNodeArraySize();
        default: return 0;
    }
}

std::string MyFindGroupMemberReplyDescriptor::getFieldAsString(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldAsString(object,field,i);
        field -= basedesc->getFieldCount(object);
    }
    MyFindGroupMemberReply *pp = (MyFindGroupMemberReply *)object; (void)pp;
    switch (field) {
        case 0: return long2string(pp->getFinger());
        case 1: {std::stringstream out; out << pp->getSucNode(i); return out.str();}
        case 2: return long2string(pp->getGroupId());
        default: return "";
    }
}

bool MyFindGroupMemberReplyDescriptor::setFieldAsString(void *object, int field, int i, const char *value) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->setFieldAsString(object,field,i,value);
        field -= basedesc->getFieldCount(object);
    }
    MyFindGroupMemberReply *pp = (MyFindGroupMemberReply *)object; (void)pp;
    switch (field) {
        case 0: pp->setFinger(string2long(value)); return true;
        case 2: pp->setGroupId(string2long(value)); return true;
        default: return false;
    }
}

const char *MyFindGroupMemberReplyDescriptor::getFieldStructName(void *object, int field) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructName(object, field);
        field -= basedesc->getFieldCount(object);
    }
    static const char *fieldStructNames[] = {
        NULL,
        "NodeHandle",
        NULL,
    };
    return (field>=0 && field<3) ? fieldStructNames[field] : NULL;
}

void *MyFindGroupMemberReplyDescriptor::getFieldStructPointer(void *object, int field, int i) const
{
    cClassDescriptor *basedesc = getBaseClassDescriptor();
    if (basedesc) {
        if (field < basedesc->getFieldCount(object))
            return basedesc->getFieldStructPointer(object, field, i);
        field -= basedesc->getFieldCount(object);
    }
    MyFindGroupMemberReply *pp = (MyFindGroupMemberReply *)object; (void)pp;
    switch (field) {
        case 1: return (void *)(&pp->getSucNode(i)); break;
        default: return NULL;
    }
}


