nedelements.h

Go to the documentation of this file.

//==========================================================================
// Part of the OMNeT++/OMNEST Discrete Event Simulation System
//
// Generated from ned.dtd by dtdclassgen.pl
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 2002-2008 Andras Varga

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

//
// THIS IS A GENERATED FILE, DO NOT EDIT!
//


#ifndef __NEDELEMENTS_H
#define __NEDELEMENTS_H

#include "nedelement.h"

NAMESPACE_BEGIN

class FilesElement;
class NedFileElement;
class CommentElement;
class PackageElement;
class ImportElement;
class PropertyDeclElement;
class ExtendsElement;
class InterfaceNameElement;
class SimpleModuleElement;
class ModuleInterfaceElement;
class CompoundModuleElement;
class ChannelInterfaceElement;
class ChannelElement;
class ParametersElement;
class ParamElement;
class PropertyElement;
class PropertyKeyElement;
class GatesElement;
class GateElement;
class TypesElement;
class SubmodulesElement;
class SubmoduleElement;
class ConnectionsElement;
class ConnectionElement;
class ConnectionGroupElement;
class LoopElement;
class ConditionElement;
class ExpressionElement;
class OperatorElement;
class FunctionElement;
class IdentElement;
class LiteralElement;
class MsgFileElement;
class NamespaceElement;
class CplusplusElement;
class StructDeclElement;
class ClassDeclElement;
class MessageDeclElement;
class PacketDeclElement;
class EnumDeclElement;
class EnumElement;
class EnumFieldsElement;
class EnumFieldElement;
class MessageElement;
class PacketElement;
class ClassElement;
class StructElement;
class FieldElement;
class UnknownElement;


enum NEDElementCode {
    NED_NULL = 0,  // 0 is reserved
    NED_FILES,
    NED_NED_FILE,
    NED_COMMENT,
    NED_PACKAGE,
    NED_IMPORT,
    NED_PROPERTY_DECL,
    NED_EXTENDS,
    NED_INTERFACE_NAME,
    NED_SIMPLE_MODULE,
    NED_MODULE_INTERFACE,
    NED_COMPOUND_MODULE,
    NED_CHANNEL_INTERFACE,
    NED_CHANNEL,
    NED_PARAMETERS,
    NED_PARAM,
    NED_PROPERTY,
    NED_PROPERTY_KEY,
    NED_GATES,
    NED_GATE,
    NED_TYPES,
    NED_SUBMODULES,
    NED_SUBMODULE,
    NED_CONNECTIONS,
    NED_CONNECTION,
    NED_CONNECTION_GROUP,
    NED_LOOP,
    NED_CONDITION,
    NED_EXPRESSION,
    NED_OPERATOR,
    NED_FUNCTION,
    NED_IDENT,
    NED_LITERAL,
    NED_MSG_FILE,
    NED_NAMESPACE,
    NED_CPLUSPLUS,
    NED_STRUCT_DECL,
    NED_CLASS_DECL,
    NED_MESSAGE_DECL,
    NED_PACKET_DECL,
    NED_ENUM_DECL,
    NED_ENUM,
    NED_ENUM_FIELDS,
    NED_ENUM_FIELD,
    NED_MESSAGE,
    NED_PACKET,
    NED_CLASS,
    NED_STRUCT,
    NED_FIELD,
    NED_UNKNOWN
};

// Note: zero *must* be a valid value for all enums, because that gets set in the ctor if there's not default
enum {NED_GATETYPE_NONE, NED_GATETYPE_INPUT, NED_GATETYPE_OUTPUT, NED_GATETYPE_INOUT};
enum {NED_PARTYPE_NONE, NED_PARTYPE_DOUBLE, NED_PARTYPE_INT, NED_PARTYPE_STRING, NED_PARTYPE_BOOL, NED_PARTYPE_XML};
enum {NED_CONST_DOUBLE, NED_CONST_INT, NED_CONST_STRING, NED_CONST_BOOL, NED_CONST_SPEC};
enum {NED_SUBGATE_NONE, NED_SUBGATE_I, NED_SUBGATE_O};

class NEDXML_API FilesElement : public NEDElement
{
  private:
  public:
    FilesElement();
    FilesElement(NEDElement *parent);
    virtual ~FilesElement() {}

    virtual const char *getTagName() const {return "files";}
    virtual int getTagCode() const {return NED_FILES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual FilesElement *dup() const;


    virtual FilesElement *getNextFilesSibling() const;
    virtual NedFileElement *getFirstNedFileChild() const;
    virtual MsgFileElement *getFirstMsgFileChild() const;
};

class NEDXML_API NedFileElement : public NEDElement
{
  private:
    std::string filename;
    std::string version;
  public:
    NedFileElement();
    NedFileElement(NEDElement *parent);
    virtual ~NedFileElement() {}

    virtual const char *getTagName() const {return "ned-file";}
    virtual int getTagCode() const {return NED_NED_FILE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual NedFileElement *dup() const;

    const char * getFilename() const  {return filename.c_str();}
    void setFilename(const char * val)  {filename = val;}
    const char * getVersion() const  {return version.c_str();}
    void setVersion(const char * val)  {version = val;}

    virtual NedFileElement *getNextNedFileSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PackageElement *getFirstPackageChild() const;
    virtual ImportElement *getFirstImportChild() const;
    virtual PropertyDeclElement *getFirstPropertyDeclChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
    virtual SimpleModuleElement *getFirstSimpleModuleChild() const;
    virtual CompoundModuleElement *getFirstCompoundModuleChild() const;
    virtual ModuleInterfaceElement *getFirstModuleInterfaceChild() const;
    virtual ChannelElement *getFirstChannelChild() const;
    virtual ChannelInterfaceElement *getFirstChannelInterfaceChild() const;
};

class NEDXML_API CommentElement : public NEDElement
{
  private:
    std::string locid;
    std::string content;
  public:
    CommentElement();
    CommentElement(NEDElement *parent);
    virtual ~CommentElement() {}

    virtual const char *getTagName() const {return "comment";}
    virtual int getTagCode() const {return NED_COMMENT;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual CommentElement *dup() const;

    const char * getLocid() const  {return locid.c_str();}
    void setLocid(const char * val)  {locid = val;}
    const char * getContent() const  {return content.c_str();}
    void setContent(const char * val)  {content = val;}

    virtual CommentElement *getNextCommentSibling() const;
};

class NEDXML_API PackageElement : public NEDElement
{
  private:
    std::string name;
  public:
    PackageElement();
    PackageElement(NEDElement *parent);
    virtual ~PackageElement() {}

    virtual const char *getTagName() const {return "package";}
    virtual int getTagCode() const {return NED_PACKAGE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual PackageElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual PackageElement *getNextPackageSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API ImportElement : public NEDElement
{
  private:
    std::string importSpec;
  public:
    ImportElement();
    ImportElement(NEDElement *parent);
    virtual ~ImportElement() {}

    virtual const char *getTagName() const {return "import";}
    virtual int getTagCode() const {return NED_IMPORT;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ImportElement *dup() const;

    const char * getImportSpec() const  {return importSpec.c_str();}
    void setImportSpec(const char * val)  {importSpec = val;}

    virtual ImportElement *getNextImportSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API PropertyDeclElement : public NEDElement
{
  private:
    std::string name;
    bool isArray;
  public:
    PropertyDeclElement();
    PropertyDeclElement(NEDElement *parent);
    virtual ~PropertyDeclElement() {}

    virtual const char *getTagName() const {return "property-decl";}
    virtual int getTagCode() const {return NED_PROPERTY_DECL;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual PropertyDeclElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    bool getIsArray() const  {return isArray;}
    void setIsArray(bool val)  {isArray = val;}

    virtual PropertyDeclElement *getNextPropertyDeclSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PropertyKeyElement *getFirstPropertyKeyChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
};

class NEDXML_API ExtendsElement : public NEDElement
{
  private:
    std::string name;
  public:
    ExtendsElement();
    ExtendsElement(NEDElement *parent);
    virtual ~ExtendsElement() {}

    virtual const char *getTagName() const {return "extends";}
    virtual int getTagCode() const {return NED_EXTENDS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ExtendsElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual ExtendsElement *getNextExtendsSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API InterfaceNameElement : public NEDElement
{
  private:
    std::string name;
  public:
    InterfaceNameElement();
    InterfaceNameElement(NEDElement *parent);
    virtual ~InterfaceNameElement() {}

    virtual const char *getTagName() const {return "interface-name";}
    virtual int getTagCode() const {return NED_INTERFACE_NAME;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual InterfaceNameElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual InterfaceNameElement *getNextInterfaceNameSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API SimpleModuleElement : public NEDElement
{
  private:
    std::string name;
  public:
    SimpleModuleElement();
    SimpleModuleElement(NEDElement *parent);
    virtual ~SimpleModuleElement() {}

    virtual const char *getTagName() const {return "simple-module";}
    virtual int getTagCode() const {return NED_SIMPLE_MODULE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual SimpleModuleElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual SimpleModuleElement *getNextSimpleModuleSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExtendsElement *getFirstExtendsChild() const;
    virtual InterfaceNameElement *getFirstInterfaceNameChild() const;
    virtual ParametersElement *getFirstParametersChild() const;
    virtual GatesElement *getFirstGatesChild() const;
};

class NEDXML_API ModuleInterfaceElement : public NEDElement
{
  private:
    std::string name;
  public:
    ModuleInterfaceElement();
    ModuleInterfaceElement(NEDElement *parent);
    virtual ~ModuleInterfaceElement() {}

    virtual const char *getTagName() const {return "module-interface";}
    virtual int getTagCode() const {return NED_MODULE_INTERFACE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ModuleInterfaceElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual ModuleInterfaceElement *getNextModuleInterfaceSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExtendsElement *getFirstExtendsChild() const;
    virtual ParametersElement *getFirstParametersChild() const;
    virtual GatesElement *getFirstGatesChild() const;
};

class NEDXML_API CompoundModuleElement : public NEDElement
{
  private:
    std::string name;
  public:
    CompoundModuleElement();
    CompoundModuleElement(NEDElement *parent);
    virtual ~CompoundModuleElement() {}

    virtual const char *getTagName() const {return "compound-module";}
    virtual int getTagCode() const {return NED_COMPOUND_MODULE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual CompoundModuleElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual CompoundModuleElement *getNextCompoundModuleSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExtendsElement *getFirstExtendsChild() const;
    virtual InterfaceNameElement *getFirstInterfaceNameChild() const;
    virtual ParametersElement *getFirstParametersChild() const;
    virtual GatesElement *getFirstGatesChild() const;
    virtual TypesElement *getFirstTypesChild() const;
    virtual SubmodulesElement *getFirstSubmodulesChild() const;
    virtual ConnectionsElement *getFirstConnectionsChild() const;
};

class NEDXML_API ChannelInterfaceElement : public NEDElement
{
  private:
    std::string name;
  public:
    ChannelInterfaceElement();
    ChannelInterfaceElement(NEDElement *parent);
    virtual ~ChannelInterfaceElement() {}

    virtual const char *getTagName() const {return "channel-interface";}
    virtual int getTagCode() const {return NED_CHANNEL_INTERFACE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ChannelInterfaceElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual ChannelInterfaceElement *getNextChannelInterfaceSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExtendsElement *getFirstExtendsChild() const;
    virtual ParametersElement *getFirstParametersChild() const;
};

class NEDXML_API ChannelElement : public NEDElement
{
  private:
    std::string name;
  public:
    ChannelElement();
    ChannelElement(NEDElement *parent);
    virtual ~ChannelElement() {}

    virtual const char *getTagName() const {return "channel";}
    virtual int getTagCode() const {return NED_CHANNEL;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ChannelElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual ChannelElement *getNextChannelSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExtendsElement *getFirstExtendsChild() const;
    virtual InterfaceNameElement *getFirstInterfaceNameChild() const;
    virtual ParametersElement *getFirstParametersChild() const;
};

class NEDXML_API ParametersElement : public NEDElement
{
  private:
    bool isImplicit;
  public:
    ParametersElement();
    ParametersElement(NEDElement *parent);
    virtual ~ParametersElement() {}

    virtual const char *getTagName() const {return "parameters";}
    virtual int getTagCode() const {return NED_PARAMETERS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ParametersElement *dup() const;

    bool getIsImplicit() const  {return isImplicit;}
    void setIsImplicit(bool val)  {isImplicit = val;}

    virtual ParametersElement *getNextParametersSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
    virtual ParamElement *getFirstParamChild() const;
};

class NEDXML_API ParamElement : public NEDElement
{
  private:
    int type;
    bool isVolatile;
    std::string name;
    std::string value;
    bool isPattern;
    bool isDefault;
  public:
    ParamElement();
    ParamElement(NEDElement *parent);
    virtual ~ParamElement() {}

    virtual const char *getTagName() const {return "param";}
    virtual int getTagCode() const {return NED_PARAM;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ParamElement *dup() const;

    int getType() const  {return type;}
    void setType(int val);
    bool getIsVolatile() const  {return isVolatile;}
    void setIsVolatile(bool val)  {isVolatile = val;}
    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getValue() const  {return value.c_str();}
    void setValue(const char * val)  {value = val;}
    bool getIsPattern() const  {return isPattern;}
    void setIsPattern(bool val)  {isPattern = val;}
    bool getIsDefault() const  {return isDefault;}
    void setIsDefault(bool val)  {isDefault = val;}

    virtual ParamElement *getNextParamSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExpressionElement *getFirstExpressionChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
};

class NEDXML_API PropertyElement : public NEDElement
{
  private:
    bool isImplicit;
    std::string name;
    std::string index;
  public:
    PropertyElement();
    PropertyElement(NEDElement *parent);
    virtual ~PropertyElement() {}

    virtual const char *getTagName() const {return "property";}
    virtual int getTagCode() const {return NED_PROPERTY;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual PropertyElement *dup() const;

    bool getIsImplicit() const  {return isImplicit;}
    void setIsImplicit(bool val)  {isImplicit = val;}
    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getIndex() const  {return index.c_str();}
    void setIndex(const char * val)  {index = val;}

    virtual PropertyElement *getNextPropertySibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PropertyKeyElement *getFirstPropertyKeyChild() const;
};

class NEDXML_API PropertyKeyElement : public NEDElement
{
  private:
    std::string name;
  public:
    PropertyKeyElement();
    PropertyKeyElement(NEDElement *parent);
    virtual ~PropertyKeyElement() {}

    virtual const char *getTagName() const {return "property-key";}
    virtual int getTagCode() const {return NED_PROPERTY_KEY;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual PropertyKeyElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual PropertyKeyElement *getNextPropertyKeySibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual LiteralElement *getFirstLiteralChild() const;
};

class NEDXML_API GatesElement : public NEDElement
{
  private:
  public:
    GatesElement();
    GatesElement(NEDElement *parent);
    virtual ~GatesElement() {}

    virtual const char *getTagName() const {return "gates";}
    virtual int getTagCode() const {return NED_GATES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual GatesElement *dup() const;


    virtual GatesElement *getNextGatesSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual GateElement *getFirstGateChild() const;
};

class NEDXML_API GateElement : public NEDElement
{
  private:
    std::string name;
    int type;
    bool isVector;
    std::string vectorSize;
  public:
    GateElement();
    GateElement(NEDElement *parent);
    virtual ~GateElement() {}

    virtual const char *getTagName() const {return "gate";}
    virtual int getTagCode() const {return NED_GATE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual GateElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    int getType() const  {return type;}
    void setType(int val);
    bool getIsVector() const  {return isVector;}
    void setIsVector(bool val)  {isVector = val;}
    const char * getVectorSize() const  {return vectorSize.c_str();}
    void setVectorSize(const char * val)  {vectorSize = val;}

    virtual GateElement *getNextGateSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExpressionElement *getFirstExpressionChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
};

class NEDXML_API TypesElement : public NEDElement
{
  private:
  public:
    TypesElement();
    TypesElement(NEDElement *parent);
    virtual ~TypesElement() {}

    virtual const char *getTagName() const {return "types";}
    virtual int getTagCode() const {return NED_TYPES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual TypesElement *dup() const;


    virtual TypesElement *getNextTypesSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ChannelElement *getFirstChannelChild() const;
    virtual ChannelInterfaceElement *getFirstChannelInterfaceChild() const;
    virtual SimpleModuleElement *getFirstSimpleModuleChild() const;
    virtual CompoundModuleElement *getFirstCompoundModuleChild() const;
    virtual ModuleInterfaceElement *getFirstModuleInterfaceChild() const;
};

class NEDXML_API SubmodulesElement : public NEDElement
{
  private:
  public:
    SubmodulesElement();
    SubmodulesElement(NEDElement *parent);
    virtual ~SubmodulesElement() {}

    virtual const char *getTagName() const {return "submodules";}
    virtual int getTagCode() const {return NED_SUBMODULES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual SubmodulesElement *dup() const;


    virtual SubmodulesElement *getNextSubmodulesSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual SubmoduleElement *getFirstSubmoduleChild() const;
};

class NEDXML_API SubmoduleElement : public NEDElement
{
  private:
    std::string name;
    std::string type;
    std::string likeType;
    std::string likeExpr;
    bool isDefault;
    std::string vectorSize;
  public:
    SubmoduleElement();
    SubmoduleElement(NEDElement *parent);
    virtual ~SubmoduleElement() {}

    virtual const char *getTagName() const {return "submodule";}
    virtual int getTagCode() const {return NED_SUBMODULE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual SubmoduleElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getType() const  {return type.c_str();}
    void setType(const char * val)  {type = val;}
    const char * getLikeType() const  {return likeType.c_str();}
    void setLikeType(const char * val)  {likeType = val;}
    const char * getLikeExpr() const  {return likeExpr.c_str();}
    void setLikeExpr(const char * val)  {likeExpr = val;}
    bool getIsDefault() const  {return isDefault;}
    void setIsDefault(bool val)  {isDefault = val;}
    const char * getVectorSize() const  {return vectorSize.c_str();}
    void setVectorSize(const char * val)  {vectorSize = val;}

    virtual SubmoduleElement *getNextSubmoduleSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExpressionElement *getFirstExpressionChild() const;
    virtual ConditionElement *getFirstConditionChild() const;
    virtual ParametersElement *getFirstParametersChild() const;
    virtual GatesElement *getFirstGatesChild() const;
};

class NEDXML_API ConnectionsElement : public NEDElement
{
  private:
    bool allowUnconnected;
  public:
    ConnectionsElement();
    ConnectionsElement(NEDElement *parent);
    virtual ~ConnectionsElement() {}

    virtual const char *getTagName() const {return "connections";}
    virtual int getTagCode() const {return NED_CONNECTIONS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ConnectionsElement *dup() const;

    bool getAllowUnconnected() const  {return allowUnconnected;}
    void setAllowUnconnected(bool val)  {allowUnconnected = val;}

    virtual ConnectionsElement *getNextConnectionsSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ConnectionElement *getFirstConnectionChild() const;
    virtual ConnectionGroupElement *getFirstConnectionGroupChild() const;
};

class NEDXML_API ConnectionElement : public NEDElement
{
  private:
    std::string srcModule;
    std::string srcModuleIndex;
    std::string srcGate;
    bool srcGatePlusplus;
    std::string srcGateIndex;
    int srcGateSubg;
    std::string destModule;
    std::string destModuleIndex;
    std::string destGate;
    bool destGatePlusplus;
    std::string destGateIndex;
    int destGateSubg;
    std::string name;
    std::string type;
    std::string likeType;
    std::string likeExpr;
    bool isDefault;
    bool isBidirectional;
    bool isForwardArrow;
  public:
    ConnectionElement();
    ConnectionElement(NEDElement *parent);
    virtual ~ConnectionElement() {}

    virtual const char *getTagName() const {return "connection";}
    virtual int getTagCode() const {return NED_CONNECTION;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ConnectionElement *dup() const;

    const char * getSrcModule() const  {return srcModule.c_str();}
    void setSrcModule(const char * val)  {srcModule = val;}
    const char * getSrcModuleIndex() const  {return srcModuleIndex.c_str();}
    void setSrcModuleIndex(const char * val)  {srcModuleIndex = val;}
    const char * getSrcGate() const  {return srcGate.c_str();}
    void setSrcGate(const char * val)  {srcGate = val;}
    bool getSrcGatePlusplus() const  {return srcGatePlusplus;}
    void setSrcGatePlusplus(bool val)  {srcGatePlusplus = val;}
    const char * getSrcGateIndex() const  {return srcGateIndex.c_str();}
    void setSrcGateIndex(const char * val)  {srcGateIndex = val;}
    int getSrcGateSubg() const  {return srcGateSubg;}
    void setSrcGateSubg(int val);
    const char * getDestModule() const  {return destModule.c_str();}
    void setDestModule(const char * val)  {destModule = val;}
    const char * getDestModuleIndex() const  {return destModuleIndex.c_str();}
    void setDestModuleIndex(const char * val)  {destModuleIndex = val;}
    const char * getDestGate() const  {return destGate.c_str();}
    void setDestGate(const char * val)  {destGate = val;}
    bool getDestGatePlusplus() const  {return destGatePlusplus;}
    void setDestGatePlusplus(bool val)  {destGatePlusplus = val;}
    const char * getDestGateIndex() const  {return destGateIndex.c_str();}
    void setDestGateIndex(const char * val)  {destGateIndex = val;}
    int getDestGateSubg() const  {return destGateSubg;}
    void setDestGateSubg(int val);
    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getType() const  {return type.c_str();}
    void setType(const char * val)  {type = val;}
    const char * getLikeType() const  {return likeType.c_str();}
    void setLikeType(const char * val)  {likeType = val;}
    const char * getLikeExpr() const  {return likeExpr.c_str();}
    void setLikeExpr(const char * val)  {likeExpr = val;}
    bool getIsDefault() const  {return isDefault;}
    void setIsDefault(bool val)  {isDefault = val;}
    bool getIsBidirectional() const  {return isBidirectional;}
    void setIsBidirectional(bool val)  {isBidirectional = val;}
    bool getIsForwardArrow() const  {return isForwardArrow;}
    void setIsForwardArrow(bool val)  {isForwardArrow = val;}

    virtual ConnectionElement *getNextConnectionSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExpressionElement *getFirstExpressionChild() const;
    virtual ParametersElement *getFirstParametersChild() const;
    virtual LoopElement *getFirstLoopChild() const;
    virtual ConditionElement *getFirstConditionChild() const;
};

class NEDXML_API ConnectionGroupElement : public NEDElement
{
  private:
  public:
    ConnectionGroupElement();
    ConnectionGroupElement(NEDElement *parent);
    virtual ~ConnectionGroupElement() {}

    virtual const char *getTagName() const {return "connection-group";}
    virtual int getTagCode() const {return NED_CONNECTION_GROUP;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ConnectionGroupElement *dup() const;


    virtual ConnectionGroupElement *getNextConnectionGroupSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual LoopElement *getFirstLoopChild() const;
    virtual ConditionElement *getFirstConditionChild() const;
    virtual ConnectionElement *getFirstConnectionChild() const;
};

class NEDXML_API LoopElement : public NEDElement
{
  private:
    std::string paramName;
    std::string fromValue;
    std::string toValue;
  public:
    LoopElement();
    LoopElement(NEDElement *parent);
    virtual ~LoopElement() {}

    virtual const char *getTagName() const {return "loop";}
    virtual int getTagCode() const {return NED_LOOP;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual LoopElement *dup() const;

    const char * getParamName() const  {return paramName.c_str();}
    void setParamName(const char * val)  {paramName = val;}
    const char * getFromValue() const  {return fromValue.c_str();}
    void setFromValue(const char * val)  {fromValue = val;}
    const char * getToValue() const  {return toValue.c_str();}
    void setToValue(const char * val)  {toValue = val;}

    virtual LoopElement *getNextLoopSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExpressionElement *getFirstExpressionChild() const;
};

class NEDXML_API ConditionElement : public NEDElement
{
  private:
    std::string condition;
  public:
    ConditionElement();
    ConditionElement(NEDElement *parent);
    virtual ~ConditionElement() {}

    virtual const char *getTagName() const {return "condition";}
    virtual int getTagCode() const {return NED_CONDITION;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ConditionElement *dup() const;

    const char * getCondition() const  {return condition.c_str();}
    void setCondition(const char * val)  {condition = val;}

    virtual ConditionElement *getNextConditionSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual ExpressionElement *getFirstExpressionChild() const;
};

class NEDXML_API ExpressionElement : public NEDElement
{
  private:
    std::string target;
  public:
    ExpressionElement();
    ExpressionElement(NEDElement *parent);
    virtual ~ExpressionElement() {}

    virtual const char *getTagName() const {return "expression";}
    virtual int getTagCode() const {return NED_EXPRESSION;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ExpressionElement *dup() const;

    const char * getTarget() const  {return target.c_str();}
    void setTarget(const char * val)  {target = val;}

    virtual ExpressionElement *getNextExpressionSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual OperatorElement *getFirstOperatorChild() const;
    virtual FunctionElement *getFirstFunctionChild() const;
    virtual IdentElement *getFirstIdentChild() const;
    virtual LiteralElement *getFirstLiteralChild() const;
};

class NEDXML_API OperatorElement : public NEDElement
{
  private:
    std::string name;
  public:
    OperatorElement();
    OperatorElement(NEDElement *parent);
    virtual ~OperatorElement() {}

    virtual const char *getTagName() const {return "operator";}
    virtual int getTagCode() const {return NED_OPERATOR;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual OperatorElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual OperatorElement *getNextOperatorSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual OperatorElement *getFirstOperatorChild() const;
    virtual FunctionElement *getFirstFunctionChild() const;
    virtual IdentElement *getFirstIdentChild() const;
    virtual LiteralElement *getFirstLiteralChild() const;
};

class NEDXML_API FunctionElement : public NEDElement
{
  private:
    std::string name;
  public:
    FunctionElement();
    FunctionElement(NEDElement *parent);
    virtual ~FunctionElement() {}

    virtual const char *getTagName() const {return "function";}
    virtual int getTagCode() const {return NED_FUNCTION;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual FunctionElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual FunctionElement *getNextFunctionSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual OperatorElement *getFirstOperatorChild() const;
    virtual FunctionElement *getFirstFunctionChild() const;
    virtual IdentElement *getFirstIdentChild() const;
    virtual LiteralElement *getFirstLiteralChild() const;
};

class NEDXML_API IdentElement : public NEDElement
{
  private:
    std::string module;
    std::string name;
  public:
    IdentElement();
    IdentElement(NEDElement *parent);
    virtual ~IdentElement() {}

    virtual const char *getTagName() const {return "ident";}
    virtual int getTagCode() const {return NED_IDENT;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual IdentElement *dup() const;

    const char * getModule() const  {return module.c_str();}
    void setModule(const char * val)  {module = val;}
    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual IdentElement *getNextIdentSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual OperatorElement *getFirstOperatorChild() const;
    virtual FunctionElement *getFirstFunctionChild() const;
    virtual IdentElement *getFirstIdentChild() const;
    virtual LiteralElement *getFirstLiteralChild() const;
};

class NEDXML_API LiteralElement : public NEDElement
{
  private:
    int type;
    std::string unit;
    std::string text;
    std::string value;
  public:
    LiteralElement();
    LiteralElement(NEDElement *parent);
    virtual ~LiteralElement() {}

    virtual const char *getTagName() const {return "literal";}
    virtual int getTagCode() const {return NED_LITERAL;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual LiteralElement *dup() const;

    int getType() const  {return type;}
    void setType(int val);
    const char * getUnit() const  {return unit.c_str();}
    void setUnit(const char * val)  {unit = val;}
    const char * getText() const  {return text.c_str();}
    void setText(const char * val)  {text = val;}
    const char * getValue() const  {return value.c_str();}
    void setValue(const char * val)  {value = val;}

    virtual LiteralElement *getNextLiteralSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API MsgFileElement : public NEDElement
{
  private:
    std::string filename;
    std::string version;
  public:
    MsgFileElement();
    MsgFileElement(NEDElement *parent);
    virtual ~MsgFileElement() {}

    virtual const char *getTagName() const {return "msg-file";}
    virtual int getTagCode() const {return NED_MSG_FILE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual MsgFileElement *dup() const;

    const char * getFilename() const  {return filename.c_str();}
    void setFilename(const char * val)  {filename = val;}
    const char * getVersion() const  {return version.c_str();}
    void setVersion(const char * val)  {version = val;}

    virtual MsgFileElement *getNextMsgFileSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual NamespaceElement *getFirstNamespaceChild() const;
    virtual PropertyDeclElement *getFirstPropertyDeclChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
    virtual CplusplusElement *getFirstCplusplusChild() const;
    virtual StructDeclElement *getFirstStructDeclChild() const;
    virtual ClassDeclElement *getFirstClassDeclChild() const;
    virtual MessageDeclElement *getFirstMessageDeclChild() const;
    virtual PacketDeclElement *getFirstPacketDeclChild() const;
    virtual EnumDeclElement *getFirstEnumDeclChild() const;
    virtual StructElement *getFirstStructChild() const;
    virtual ClassElement *getFirstClassChild() const;
    virtual MessageElement *getFirstMessageChild() const;
    virtual PacketElement *getFirstPacketChild() const;
    virtual EnumElement *getFirstEnumChild() const;
};

class NEDXML_API NamespaceElement : public NEDElement
{
  private:
    std::string name;
  public:
    NamespaceElement();
    NamespaceElement(NEDElement *parent);
    virtual ~NamespaceElement() {}

    virtual const char *getTagName() const {return "namespace";}
    virtual int getTagCode() const {return NED_NAMESPACE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual NamespaceElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual NamespaceElement *getNextNamespaceSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API CplusplusElement : public NEDElement
{
  private:
    std::string body;
  public:
    CplusplusElement();
    CplusplusElement(NEDElement *parent);
    virtual ~CplusplusElement() {}

    virtual const char *getTagName() const {return "cplusplus";}
    virtual int getTagCode() const {return NED_CPLUSPLUS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual CplusplusElement *dup() const;

    const char * getBody() const  {return body.c_str();}
    void setBody(const char * val)  {body = val;}

    virtual CplusplusElement *getNextCplusplusSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API StructDeclElement : public NEDElement
{
  private:
    std::string name;
  public:
    StructDeclElement();
    StructDeclElement(NEDElement *parent);
    virtual ~StructDeclElement() {}

    virtual const char *getTagName() const {return "struct-decl";}
    virtual int getTagCode() const {return NED_STRUCT_DECL;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual StructDeclElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual StructDeclElement *getNextStructDeclSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API ClassDeclElement : public NEDElement
{
  private:
    std::string name;
    bool isCobject;
    std::string extendsName;
  public:
    ClassDeclElement();
    ClassDeclElement(NEDElement *parent);
    virtual ~ClassDeclElement() {}

    virtual const char *getTagName() const {return "class-decl";}
    virtual int getTagCode() const {return NED_CLASS_DECL;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ClassDeclElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    bool getIsCobject() const  {return isCobject;}
    void setIsCobject(bool val)  {isCobject = val;}
    const char * getExtendsName() const  {return extendsName.c_str();}
    void setExtendsName(const char * val)  {extendsName = val;}

    virtual ClassDeclElement *getNextClassDeclSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API MessageDeclElement : public NEDElement
{
  private:
    std::string name;
  public:
    MessageDeclElement();
    MessageDeclElement(NEDElement *parent);
    virtual ~MessageDeclElement() {}

    virtual const char *getTagName() const {return "message-decl";}
    virtual int getTagCode() const {return NED_MESSAGE_DECL;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual MessageDeclElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual MessageDeclElement *getNextMessageDeclSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API PacketDeclElement : public NEDElement
{
  private:
    std::string name;
  public:
    PacketDeclElement();
    PacketDeclElement(NEDElement *parent);
    virtual ~PacketDeclElement() {}

    virtual const char *getTagName() const {return "packet-decl";}
    virtual int getTagCode() const {return NED_PACKET_DECL;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual PacketDeclElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual PacketDeclElement *getNextPacketDeclSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API EnumDeclElement : public NEDElement
{
  private:
    std::string name;
  public:
    EnumDeclElement();
    EnumDeclElement(NEDElement *parent);
    virtual ~EnumDeclElement() {}

    virtual const char *getTagName() const {return "enum-decl";}
    virtual int getTagCode() const {return NED_ENUM_DECL;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual EnumDeclElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}

    virtual EnumDeclElement *getNextEnumDeclSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API EnumElement : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
  public:
    EnumElement();
    EnumElement(NEDElement *parent);
    virtual ~EnumElement() {}

    virtual const char *getTagName() const {return "enum";}
    virtual int getTagCode() const {return NED_ENUM;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual EnumElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getExtendsName() const  {return extendsName.c_str();}
    void setExtendsName(const char * val)  {extendsName = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}

    virtual EnumElement *getNextEnumSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual EnumFieldsElement *getFirstEnumFieldsChild() const;
};

class NEDXML_API EnumFieldsElement : public NEDElement
{
  private:
  public:
    EnumFieldsElement();
    EnumFieldsElement(NEDElement *parent);
    virtual ~EnumFieldsElement() {}

    virtual const char *getTagName() const {return "enum-fields";}
    virtual int getTagCode() const {return NED_ENUM_FIELDS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual EnumFieldsElement *dup() const;


    virtual EnumFieldsElement *getNextEnumFieldsSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual EnumFieldElement *getFirstEnumFieldChild() const;
};

class NEDXML_API EnumFieldElement : public NEDElement
{
  private:
    std::string name;
    std::string value;
  public:
    EnumFieldElement();
    EnumFieldElement(NEDElement *parent);
    virtual ~EnumFieldElement() {}

    virtual const char *getTagName() const {return "enum-field";}
    virtual int getTagCode() const {return NED_ENUM_FIELD;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual EnumFieldElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getValue() const  {return value.c_str();}
    void setValue(const char * val)  {value = val;}

    virtual EnumFieldElement *getNextEnumFieldSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
};

class NEDXML_API MessageElement : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
  public:
    MessageElement();
    MessageElement(NEDElement *parent);
    virtual ~MessageElement() {}

    virtual const char *getTagName() const {return "message";}
    virtual int getTagCode() const {return NED_MESSAGE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual MessageElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getExtendsName() const  {return extendsName.c_str();}
    void setExtendsName(const char * val)  {extendsName = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}

    virtual MessageElement *getNextMessageSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
    virtual FieldElement *getFirstFieldChild() const;
};

class NEDXML_API PacketElement : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
  public:
    PacketElement();
    PacketElement(NEDElement *parent);
    virtual ~PacketElement() {}

    virtual const char *getTagName() const {return "packet";}
    virtual int getTagCode() const {return NED_PACKET;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual PacketElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getExtendsName() const  {return extendsName.c_str();}
    void setExtendsName(const char * val)  {extendsName = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}

    virtual PacketElement *getNextPacketSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
    virtual FieldElement *getFirstFieldChild() const;
};

class NEDXML_API ClassElement : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
  public:
    ClassElement();
    ClassElement(NEDElement *parent);
    virtual ~ClassElement() {}

    virtual const char *getTagName() const {return "class";}
    virtual int getTagCode() const {return NED_CLASS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual ClassElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getExtendsName() const  {return extendsName.c_str();}
    void setExtendsName(const char * val)  {extendsName = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}

    virtual ClassElement *getNextClassSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
    virtual FieldElement *getFirstFieldChild() const;
};

class NEDXML_API StructElement : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
  public:
    StructElement();
    StructElement(NEDElement *parent);
    virtual ~StructElement() {}

    virtual const char *getTagName() const {return "struct";}
    virtual int getTagCode() const {return NED_STRUCT;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual StructElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getExtendsName() const  {return extendsName.c_str();}
    void setExtendsName(const char * val)  {extendsName = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}

    virtual StructElement *getNextStructSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
    virtual FieldElement *getFirstFieldChild() const;
};

class NEDXML_API FieldElement : public NEDElement
{
  private:
    std::string name;
    std::string dataType;
    bool isAbstract;
    bool isReadonly;
    bool isVector;
    std::string vectorSize;
    std::string defaultValue;
  public:
    FieldElement();
    FieldElement(NEDElement *parent);
    virtual ~FieldElement() {}

    virtual const char *getTagName() const {return "field";}
    virtual int getTagCode() const {return NED_FIELD;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual FieldElement *dup() const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getDataType() const  {return dataType.c_str();}
    void setDataType(const char * val)  {dataType = val;}
    bool getIsAbstract() const  {return isAbstract;}
    void setIsAbstract(bool val)  {isAbstract = val;}
    bool getIsReadonly() const  {return isReadonly;}
    void setIsReadonly(bool val)  {isReadonly = val;}
    bool getIsVector() const  {return isVector;}
    void setIsVector(bool val)  {isVector = val;}
    const char * getVectorSize() const  {return vectorSize.c_str();}
    void setVectorSize(const char * val)  {vectorSize = val;}
    const char * getDefaultValue() const  {return defaultValue.c_str();}
    void setDefaultValue(const char * val)  {defaultValue = val;}

    virtual FieldElement *getNextFieldSibling() const;
    virtual CommentElement *getFirstCommentChild() const;
    virtual PropertyElement *getFirstPropertyChild() const;
};

class NEDXML_API UnknownElement : public NEDElement
{
  private:
    std::string element;
  public:
    UnknownElement();
    UnknownElement(NEDElement *parent);
    virtual ~UnknownElement() {}

    virtual const char *getTagName() const {return "unknown";}
    virtual int getTagCode() const {return NED_UNKNOWN;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual const char *getAttribute(const char *name) const {return NEDElement::getAttribute(name);} // needed because of a C++ language quirk
    virtual void setAttribute(int k, const char *val);
    virtual void setAttribute(const char *name, const char *val) {NEDElement::setAttribute(name, val);} // ditto
    virtual const char *getAttributeDefault(int k) const;
    virtual UnknownElement *dup() const;

    const char * getElement() const  {return element.c_str();}
    void setElement(const char * val)  {element = val;}

    virtual UnknownElement *getNextUnknownSibling() const;
};

class NEDXML_API NEDElementFactory
{
  private:
    static NEDElementFactory *f;
    // ctor is private, because only one instance is allowed
    NEDElementFactory() {}
  public:
    virtual ~NEDElementFactory() {}
    static NEDElementFactory *getInstance();
    virtual NEDElement *createElementWithTag(const char *tagname);
    virtual NEDElement *createElementWithTag(int tagcode);
};

NAMESPACE_END

#endif

---