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-2005 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"

class NedFilesNode;
class NedFileNode;
class ImportNode;
class ImportedFileNode;
class ChannelNode;
class ChannelAttrNode;
class NetworkNode;
class SimpleModuleNode;
class CompoundModuleNode;
class ParamsNode;
class ParamNode;
class GatesNode;
class GateNode;
class MachinesNode;
class MachineNode;
class SubmodulesNode;
class SubmoduleNode;
class SubstparamsNode;
class SubstparamNode;
class GatesizesNode;
class GatesizeNode;
class SubstmachinesNode;
class SubstmachineNode;
class ConnectionsNode;
class ConnectionNode;
class ConnAttrNode;
class ForLoopNode;
class LoopVarNode;
class DisplayStringNode;
class ExpressionNode;
class OperatorNode;
class FunctionNode;
class ParamRefNode;
class IdentNode;
class ConstNode;
class CplusplusNode;
class StructDeclNode;
class ClassDeclNode;
class EnumDeclNode;
class EnumNode;
class EnumFieldsNode;
class EnumFieldNode;
class MessageNode;
class ClassNode;
class StructNode;
class FieldsNode;
class FieldNode;
class PropertiesNode;
class PropertyNode;
class UnknownNode;


enum NEDElementCode {
    NED_NED_FILES,
    NED_NED_FILE,
    NED_IMPORT,
    NED_IMPORTED_FILE,
    NED_CHANNEL,
    NED_CHANNEL_ATTR,
    NED_NETWORK,
    NED_SIMPLE_MODULE,
    NED_COMPOUND_MODULE,
    NED_PARAMS,
    NED_PARAM,
    NED_GATES,
    NED_GATE,
    NED_MACHINES,
    NED_MACHINE,
    NED_SUBMODULES,
    NED_SUBMODULE,
    NED_SUBSTPARAMS,
    NED_SUBSTPARAM,
    NED_GATESIZES,
    NED_GATESIZE,
    NED_SUBSTMACHINES,
    NED_SUBSTMACHINE,
    NED_CONNECTIONS,
    NED_CONNECTION,
    NED_CONN_ATTR,
    NED_FOR_LOOP,
    NED_LOOP_VAR,
    NED_DISPLAY_STRING,
    NED_EXPRESSION,
    NED_OPERATOR,
    NED_FUNCTION,
    NED_PARAM_REF,
    NED_IDENT,
    NED_CONST,
    NED_CPLUSPLUS,
    NED_STRUCT_DECL,
    NED_CLASS_DECL,
    NED_ENUM_DECL,
    NED_ENUM,
    NED_ENUM_FIELDS,
    NED_ENUM_FIELD,
    NED_MESSAGE,
    NED_CLASS,
    NED_STRUCT,
    NED_FIELDS,
    NED_FIELD,
    NED_PROPERTIES,
    NED_PROPERTY,
    NED_UNKNOWN,
};

enum {NED_GATEDIR_INPUT, NED_GATEDIR_OUTPUT};
enum {NED_ARROWDIR_LEFT, NED_ARROWDIR_RIGHT};
enum {NED_CONST_BOOL, NED_CONST_INT, NED_CONST_REAL, NED_CONST_STRING, NED_CONST_TIME};

class NedFilesNode : public NEDElement
{
  private:
  public:
    NedFilesNode() {applyDefaults();}
    NedFilesNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~NedFilesNode() {}

    virtual const char *getTagName() const {return "ned-files";}
    virtual int getTagCode() const {return NED_NED_FILES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;


    virtual NedFilesNode *getNextNedFilesNodeSibling() const;
    virtual NedFilesNode *getFirstNedFilesChild() const;
    virtual NedFileNode *getFirstNedFileChild() const;
};

class NedFileNode : public NEDElement
{
  private:
    std::string filename;
    std::string sourceCode;
    std::string preferredIndent;
    std::string bannerComment;
  public:
    NedFileNode() {applyDefaults();}
    NedFileNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~NedFileNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getFilename() const  {return filename.c_str();}
    void setFilename(const char * val)  {filename = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}
    const char * getPreferredIndent() const  {return preferredIndent.c_str();}
    void setPreferredIndent(const char * val)  {preferredIndent = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}

    virtual NedFileNode *getNextNedFileNodeSibling() const;
    virtual ImportNode *getFirstImportChild() const;
    virtual ChannelNode *getFirstChannelChild() const;
    virtual SimpleModuleNode *getFirstSimpleModuleChild() const;
    virtual CompoundModuleNode *getFirstCompoundModuleChild() const;
    virtual NetworkNode *getFirstNetworkChild() const;
    virtual CplusplusNode *getFirstCplusplusChild() const;
    virtual StructDeclNode *getFirstStructDeclChild() const;
    virtual ClassDeclNode *getFirstClassDeclChild() const;
    virtual EnumDeclNode *getFirstEnumDeclChild() const;
    virtual EnumNode *getFirstEnumChild() const;
    virtual MessageNode *getFirstMessageChild() const;
    virtual ClassNode *getFirstClassChild() const;
    virtual StructNode *getFirstStructChild() const;
};

class ImportNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
  public:
    ImportNode() {applyDefaults();}
    ImportNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ImportNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual ImportNode *getNextImportNodeSibling() const;
    virtual ImportedFileNode *getFirstImportedFileChild() const;
};

class ImportedFileNode : public NEDElement
{
  private:
    std::string filename;
    std::string bannerComment;
    std::string rightComment;
  public:
    ImportedFileNode() {applyDefaults();}
    ImportedFileNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ImportedFileNode() {}

    virtual const char *getTagName() const {return "imported-file";}
    virtual int getTagCode() const {return NED_IMPORTED_FILE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getFilename() const  {return filename.c_str();}
    void setFilename(const char * val)  {filename = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual ImportedFileNode *getNextImportedFileNodeSibling() const;
};

class ChannelNode : public NEDElement
{
  private:
    std::string name;
    std::string sourceCode;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    ChannelNode() {applyDefaults();}
    ChannelNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ChannelNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual ChannelNode *getNextChannelNodeSibling() const;
    virtual ChannelAttrNode *getFirstChannelAttrChild() const;
    virtual DisplayStringNode *getFirstDisplayStringChild() const;
};

class ChannelAttrNode : public NEDElement
{
  private:
    std::string name;
    std::string value;
    std::string bannerComment;
    std::string rightComment;
  public:
    ChannelAttrNode() {applyDefaults();}
    ChannelAttrNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ChannelAttrNode() {}

    virtual const char *getTagName() const {return "channel-attr";}
    virtual int getTagCode() const {return NED_CHANNEL_ATTR;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual ChannelAttrNode *getNextChannelAttrNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
};

class NetworkNode : public NEDElement
{
  private:
    std::string name;
    std::string typeName;
    std::string sourceCode;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    NetworkNode() {applyDefaults();}
    NetworkNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~NetworkNode() {}

    virtual const char *getTagName() const {return "network";}
    virtual int getTagCode() const {return NED_NETWORK;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getTypeName() const  {return typeName.c_str();}
    void setTypeName(const char * val)  {typeName = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual NetworkNode *getNextNetworkNodeSibling() const;
    virtual SubstmachinesNode *getFirstSubstmachinesChild() const;
    virtual SubstparamsNode *getFirstSubstparamsChild() const;
};

class SimpleModuleNode : public NEDElement
{
  private:
    std::string name;
    std::string sourceCode;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    SimpleModuleNode() {applyDefaults();}
    SimpleModuleNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~SimpleModuleNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual SimpleModuleNode *getNextSimpleModuleNodeSibling() const;
    virtual MachinesNode *getFirstMachinesChild() const;
    virtual ParamsNode *getFirstParamsChild() const;
    virtual GatesNode *getFirstGatesChild() const;
    virtual DisplayStringNode *getFirstDisplayStringChild() const;
};

class CompoundModuleNode : public NEDElement
{
  private:
    std::string name;
    std::string sourceCode;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    CompoundModuleNode() {applyDefaults();}
    CompoundModuleNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~CompoundModuleNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getSourceCode() const  {return sourceCode.c_str();}
    void setSourceCode(const char * val)  {sourceCode = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual CompoundModuleNode *getNextCompoundModuleNodeSibling() const;
    virtual MachinesNode *getFirstMachinesChild() const;
    virtual ParamsNode *getFirstParamsChild() const;
    virtual GatesNode *getFirstGatesChild() const;
    virtual SubmodulesNode *getFirstSubmodulesChild() const;
    virtual ConnectionsNode *getFirstConnectionsChild() const;
    virtual DisplayStringNode *getFirstDisplayStringChild() const;
};

class ParamsNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
  public:
    ParamsNode() {applyDefaults();}
    ParamsNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ParamsNode() {}

    virtual const char *getTagName() const {return "params";}
    virtual int getTagCode() const {return NED_PARAMS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual ParamsNode *getNextParamsNodeSibling() const;
    virtual ParamNode *getFirstParamChild() const;
};

class ParamNode : public NEDElement
{
  private:
    std::string name;
    std::string dataType;
    std::string bannerComment;
    std::string rightComment;
  public:
    ParamNode() {applyDefaults();}
    ParamNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ParamNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual ParamNode *getNextParamNodeSibling() const;
};

class GatesNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
  public:
    GatesNode() {applyDefaults();}
    GatesNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~GatesNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual GatesNode *getNextGatesNodeSibling() const;
    virtual GateNode *getFirstGateChild() const;
};

class GateNode : public NEDElement
{
  private:
    std::string name;
    int direction;
    bool isVector;
    std::string bannerComment;
    std::string rightComment;
  public:
    GateNode() {applyDefaults();}
    GateNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~GateNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    int getDirection() const  {return direction;}
    void setDirection(int val)  {direction = val;}
    bool getIsVector() const  {return isVector;}
    void setIsVector(bool val)  {isVector = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual GateNode *getNextGateNodeSibling() const;
};

class MachinesNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
  public:
    MachinesNode() {applyDefaults();}
    MachinesNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~MachinesNode() {}

    virtual const char *getTagName() const {return "machines";}
    virtual int getTagCode() const {return NED_MACHINES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual MachinesNode *getNextMachinesNodeSibling() const;
    virtual MachineNode *getFirstMachineChild() const;
};

class MachineNode : public NEDElement
{
  private:
    std::string name;
    std::string bannerComment;
    std::string rightComment;
  public:
    MachineNode() {applyDefaults();}
    MachineNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~MachineNode() {}

    virtual const char *getTagName() const {return "machine";}
    virtual int getTagCode() const {return NED_MACHINE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual MachineNode *getNextMachineNodeSibling() const;
};

class SubmodulesNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
  public:
    SubmodulesNode() {applyDefaults();}
    SubmodulesNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~SubmodulesNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual SubmodulesNode *getNextSubmodulesNodeSibling() const;
    virtual SubmoduleNode *getFirstSubmoduleChild() const;
};

class SubmoduleNode : public NEDElement
{
  private:
    std::string name;
    std::string typeName;
    std::string likeParam;
    std::string vectorSize;
    std::string bannerComment;
    std::string rightComment;
  public:
    SubmoduleNode() {applyDefaults();}
    SubmoduleNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~SubmoduleNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getTypeName() const  {return typeName.c_str();}
    void setTypeName(const char * val)  {typeName = val;}
    const char * getLikeParam() const  {return likeParam.c_str();}
    void setLikeParam(const char * val)  {likeParam = val;}
    const char * getVectorSize() const  {return vectorSize.c_str();}
    void setVectorSize(const char * val)  {vectorSize = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual SubmoduleNode *getNextSubmoduleNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
    virtual SubstmachinesNode *getFirstSubstmachinesChild() const;
    virtual SubstparamsNode *getFirstSubstparamsChild() const;
    virtual GatesizesNode *getFirstGatesizesChild() const;
    virtual DisplayStringNode *getFirstDisplayStringChild() const;
};

class SubstparamsNode : public NEDElement
{
  private:
    std::string condition;
    std::string bannerComment;
    std::string rightComment;
  public:
    SubstparamsNode() {applyDefaults();}
    SubstparamsNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~SubstparamsNode() {}

    virtual const char *getTagName() const {return "substparams";}
    virtual int getTagCode() const {return NED_SUBSTPARAMS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getCondition() const  {return condition.c_str();}
    void setCondition(const char * val)  {condition = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual SubstparamsNode *getNextSubstparamsNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
    virtual SubstparamNode *getFirstSubstparamChild() const;
};

class SubstparamNode : public NEDElement
{
  private:
    std::string name;
    std::string value;
    std::string bannerComment;
    std::string rightComment;
  public:
    SubstparamNode() {applyDefaults();}
    SubstparamNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~SubstparamNode() {}

    virtual const char *getTagName() const {return "substparam";}
    virtual int getTagCode() const {return NED_SUBSTPARAM;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual SubstparamNode *getNextSubstparamNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
};

class GatesizesNode : public NEDElement
{
  private:
    std::string condition;
    std::string bannerComment;
    std::string rightComment;
  public:
    GatesizesNode() {applyDefaults();}
    GatesizesNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~GatesizesNode() {}

    virtual const char *getTagName() const {return "gatesizes";}
    virtual int getTagCode() const {return NED_GATESIZES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getCondition() const  {return condition.c_str();}
    void setCondition(const char * val)  {condition = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual GatesizesNode *getNextGatesizesNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
    virtual GatesizeNode *getFirstGatesizeChild() const;
};

class GatesizeNode : public NEDElement
{
  private:
    std::string name;
    std::string vectorSize;
    std::string bannerComment;
    std::string rightComment;
  public:
    GatesizeNode() {applyDefaults();}
    GatesizeNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~GatesizeNode() {}

    virtual const char *getTagName() const {return "gatesize";}
    virtual int getTagCode() const {return NED_GATESIZE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getVectorSize() const  {return vectorSize.c_str();}
    void setVectorSize(const char * val)  {vectorSize = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual GatesizeNode *getNextGatesizeNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
};

class SubstmachinesNode : public NEDElement
{
  private:
    std::string condition;
    std::string bannerComment;
    std::string rightComment;
  public:
    SubstmachinesNode() {applyDefaults();}
    SubstmachinesNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~SubstmachinesNode() {}

    virtual const char *getTagName() const {return "substmachines";}
    virtual int getTagCode() const {return NED_SUBSTMACHINES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getCondition() const  {return condition.c_str();}
    void setCondition(const char * val)  {condition = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual SubstmachinesNode *getNextSubstmachinesNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
    virtual SubstmachineNode *getFirstSubstmachineChild() const;
};

class SubstmachineNode : public NEDElement
{
  private:
    std::string name;
    std::string bannerComment;
    std::string rightComment;
  public:
    SubstmachineNode() {applyDefaults();}
    SubstmachineNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~SubstmachineNode() {}

    virtual const char *getTagName() const {return "substmachine";}
    virtual int getTagCode() const {return NED_SUBSTMACHINE;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual SubstmachineNode *getNextSubstmachineNodeSibling() const;
};

class ConnectionsNode : public NEDElement
{
  private:
    bool checkUnconnected;
    std::string bannerComment;
    std::string rightComment;
  public:
    ConnectionsNode() {applyDefaults();}
    ConnectionsNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ConnectionsNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    bool getCheckUnconnected() const  {return checkUnconnected;}
    void setCheckUnconnected(bool val)  {checkUnconnected = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual ConnectionsNode *getNextConnectionsNodeSibling() const;
    virtual ConnectionNode *getFirstConnectionChild() const;
    virtual ForLoopNode *getFirstForLoopChild() const;
};

class ConnectionNode : public NEDElement
{
  private:
    std::string condition;
    std::string srcModule;
    std::string srcModuleIndex;
    std::string srcGate;
    bool srcGatePlusplus;
    std::string srcGateIndex;
    std::string destModule;
    std::string destModuleIndex;
    std::string destGate;
    bool destGatePlusplus;
    std::string destGateIndex;
    int arrowDirection;
    std::string bannerComment;
    std::string rightComment;
  public:
    ConnectionNode() {applyDefaults();}
    ConnectionNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ConnectionNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getCondition() const  {return condition.c_str();}
    void setCondition(const char * val)  {condition = val;}
    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;}
    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 getArrowDirection() const  {return arrowDirection;}
    void setArrowDirection(int val)  {arrowDirection = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual ConnectionNode *getNextConnectionNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
    virtual ConnAttrNode *getFirstConnAttrChild() const;
    virtual DisplayStringNode *getFirstDisplayStringChild() const;
};

class ConnAttrNode : public NEDElement
{
  private:
    std::string name;
    std::string value;
    std::string rightComment;
  public:
    ConnAttrNode() {applyDefaults();}
    ConnAttrNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ConnAttrNode() {}

    virtual const char *getTagName() const {return "conn-attr";}
    virtual int getTagCode() const {return NED_CONN_ATTR;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual ConnAttrNode *getNextConnAttrNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
};

class ForLoopNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    ForLoopNode() {applyDefaults();}
    ForLoopNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ForLoopNode() {}

    virtual const char *getTagName() const {return "for-loop";}
    virtual int getTagCode() const {return NED_FOR_LOOP;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual ForLoopNode *getNextForLoopNodeSibling() const;
    virtual LoopVarNode *getFirstLoopVarChild() const;
    virtual ConnectionNode *getFirstConnectionChild() const;
};

class LoopVarNode : public NEDElement
{
  private:
    std::string paramName;
    std::string fromValue;
    std::string toValue;
    std::string bannerComment;
    std::string rightComment;
  public:
    LoopVarNode() {applyDefaults();}
    LoopVarNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~LoopVarNode() {}

    virtual const char *getTagName() const {return "loop-var";}
    virtual int getTagCode() const {return NED_LOOP_VAR;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual LoopVarNode *getNextLoopVarNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
};

class DisplayStringNode : public NEDElement
{
  private:
    std::string value;
    std::string bannerComment;
    std::string rightComment;
  public:
    DisplayStringNode() {applyDefaults();}
    DisplayStringNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~DisplayStringNode() {}

    virtual const char *getTagName() const {return "display-string";}
    virtual int getTagCode() const {return NED_DISPLAY_STRING;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getValue() const  {return value.c_str();}
    void setValue(const char * val)  {value = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual DisplayStringNode *getNextDisplayStringNodeSibling() const;
};

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

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

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

    virtual ExpressionNode *getNextExpressionNodeSibling() const;
    virtual OperatorNode *getFirstOperatorChild() const;
    virtual FunctionNode *getFirstFunctionChild() const;
    virtual ParamRefNode *getFirstParamRefChild() const;
    virtual IdentNode *getFirstIdentChild() const;
    virtual ConstNode *getFirstConstChild() const;
};

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

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

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

    virtual OperatorNode *getNextOperatorNodeSibling() const;
    virtual OperatorNode *getFirstOperatorChild() const;
    virtual FunctionNode *getFirstFunctionChild() const;
    virtual ParamRefNode *getFirstParamRefChild() const;
    virtual IdentNode *getFirstIdentChild() const;
    virtual ConstNode *getFirstConstChild() const;
};

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

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

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

    virtual FunctionNode *getNextFunctionNodeSibling() const;
    virtual OperatorNode *getFirstOperatorChild() const;
    virtual FunctionNode *getFirstFunctionChild() const;
    virtual ParamRefNode *getFirstParamRefChild() const;
    virtual IdentNode *getFirstIdentChild() const;
    virtual ConstNode *getFirstConstChild() const;
};

class ParamRefNode : public NEDElement
{
  private:
    std::string module;
    std::string moduleIndex;
    std::string paramName;
    std::string paramIndex;
    bool isRef;
    bool isAncestor;
  public:
    ParamRefNode() {applyDefaults();}
    ParamRefNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ParamRefNode() {}

    virtual const char *getTagName() const {return "param-ref";}
    virtual int getTagCode() const {return NED_PARAM_REF;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getModule() const  {return module.c_str();}
    void setModule(const char * val)  {module = val;}
    const char * getModuleIndex() const  {return moduleIndex.c_str();}
    void setModuleIndex(const char * val)  {moduleIndex = val;}
    const char * getParamName() const  {return paramName.c_str();}
    void setParamName(const char * val)  {paramName = val;}
    const char * getParamIndex() const  {return paramIndex.c_str();}
    void setParamIndex(const char * val)  {paramIndex = val;}
    bool getIsRef() const  {return isRef;}
    void setIsRef(bool val)  {isRef = val;}
    bool getIsAncestor() const  {return isAncestor;}
    void setIsAncestor(bool val)  {isAncestor = val;}

    virtual ParamRefNode *getNextParamRefNodeSibling() const;
    virtual ExpressionNode *getFirstExpressionChild() const;
};

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

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

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

    virtual IdentNode *getNextIdentNodeSibling() const;
};

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

    virtual const char *getTagName() const {return "const";}
    virtual int getTagCode() const {return NED_CONST;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    int getType() const  {return type;}
    void setType(int val)  {type = 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 ConstNode *getNextConstNodeSibling() const;
};

class CplusplusNode : public NEDElement
{
  private:
    std::string body;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    CplusplusNode() {applyDefaults();}
    CplusplusNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~CplusplusNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBody() const  {return body.c_str();}
    void setBody(const char * val)  {body = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual CplusplusNode *getNextCplusplusNodeSibling() const;
};

class StructDeclNode : public NEDElement
{
  private:
    std::string name;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    StructDeclNode() {applyDefaults();}
    StructDeclNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~StructDeclNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual StructDeclNode *getNextStructDeclNodeSibling() const;
};

class ClassDeclNode : public NEDElement
{
  private:
    std::string name;
    bool isCobject;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    ClassDeclNode() {applyDefaults();}
    ClassDeclNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ClassDeclNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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 * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual ClassDeclNode *getNextClassDeclNodeSibling() const;
};

class EnumDeclNode : public NEDElement
{
  private:
    std::string name;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    EnumDeclNode() {applyDefaults();}
    EnumDeclNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~EnumDeclNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getName() const  {return name.c_str();}
    void setName(const char * val)  {name = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual EnumDeclNode *getNextEnumDeclNodeSibling() const;
};

class EnumNode : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    EnumNode() {applyDefaults();}
    EnumNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~EnumNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual EnumNode *getNextEnumNodeSibling() const;
    virtual EnumFieldsNode *getFirstEnumFieldsChild() const;
};

class EnumFieldsNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
  public:
    EnumFieldsNode() {applyDefaults();}
    EnumFieldsNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~EnumFieldsNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual EnumFieldsNode *getNextEnumFieldsNodeSibling() const;
    virtual EnumFieldNode *getFirstEnumFieldChild() const;
};

class EnumFieldNode : public NEDElement
{
  private:
    std::string name;
    std::string value;
    std::string bannerComment;
    std::string rightComment;
  public:
    EnumFieldNode() {applyDefaults();}
    EnumFieldNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~EnumFieldNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual EnumFieldNode *getNextEnumFieldNodeSibling() const;
};

class MessageNode : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    MessageNode() {applyDefaults();}
    MessageNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~MessageNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual MessageNode *getNextMessageNodeSibling() const;
    virtual PropertiesNode *getFirstPropertiesChild() const;
    virtual FieldsNode *getFirstFieldsChild() const;
};

class ClassNode : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    ClassNode() {applyDefaults();}
    ClassNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~ClassNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual ClassNode *getNextClassNodeSibling() const;
    virtual PropertiesNode *getFirstPropertiesChild() const;
    virtual FieldsNode *getFirstFieldsChild() const;
};

class StructNode : public NEDElement
{
  private:
    std::string name;
    std::string extendsName;
    std::string sourceCode;
    std::string bannerComment;
    std::string rightComment;
    std::string trailingComment;
  public:
    StructNode() {applyDefaults();}
    StructNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~StructNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}
    const char * getTrailingComment() const  {return trailingComment.c_str();}
    void setTrailingComment(const char * val)  {trailingComment = val;}

    virtual StructNode *getNextStructNodeSibling() const;
    virtual PropertiesNode *getFirstPropertiesChild() const;
    virtual FieldsNode *getFirstFieldsChild() const;
};

class FieldsNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
  public:
    FieldsNode() {applyDefaults();}
    FieldsNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~FieldsNode() {}

    virtual const char *getTagName() const {return "fields";}
    virtual int getTagCode() const {return NED_FIELDS;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual FieldsNode *getNextFieldsNodeSibling() const;
    virtual FieldNode *getFirstFieldChild() const;
};

class FieldNode : public NEDElement
{
  private:
    std::string name;
    std::string dataType;
    bool isAbstract;
    bool isVector;
    std::string vectorSize;
    std::string enumName;
    std::string defaultValue;
    std::string bannerComment;
    std::string rightComment;
  public:
    FieldNode() {applyDefaults();}
    FieldNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~FieldNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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 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 * getEnumName() const  {return enumName.c_str();}
    void setEnumName(const char * val)  {enumName = val;}
    const char * getDefaultValue() const  {return defaultValue.c_str();}
    void setDefaultValue(const char * val)  {defaultValue = val;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual FieldNode *getNextFieldNodeSibling() const;
};

class PropertiesNode : public NEDElement
{
  private:
    std::string bannerComment;
    std::string rightComment;
  public:
    PropertiesNode() {applyDefaults();}
    PropertiesNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~PropertiesNode() {}

    virtual const char *getTagName() const {return "properties";}
    virtual int getTagCode() const {return NED_PROPERTIES;}
    virtual int getNumAttributes() const;
    virtual const char *getAttributeName(int k) const;
    virtual const char *getAttribute(int k) const;
    virtual void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual PropertiesNode *getNextPropertiesNodeSibling() const;
    virtual PropertyNode *getFirstPropertyChild() const;
};

class PropertyNode : public NEDElement
{
  private:
    std::string name;
    std::string value;
    std::string bannerComment;
    std::string rightComment;
  public:
    PropertyNode() {applyDefaults();}
    PropertyNode(NEDElement *parent) : NEDElement(parent) {applyDefaults();}
    virtual ~PropertyNode() {}

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) 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;}
    const char * getBannerComment() const  {return bannerComment.c_str();}
    void setBannerComment(const char * val)  {bannerComment = val;}
    const char * getRightComment() const  {return rightComment.c_str();}
    void setRightComment(const char * val)  {rightComment = val;}

    virtual PropertyNode *getNextPropertyNodeSibling() const;
};

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

    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 void setAttribute(int k, const char *val);
    virtual const char *getAttributeDefault(int k) const;

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

    virtual UnknownNode *getNextUnknownNodeSibling() const;
};

class NEDElementFactory
{
  protected:
    static NEDElementFactory *f;
  public:
    static NEDElementFactory *getInstance();
    virtual NEDElement *createNodeWithTag(const char *tagname);
    virtual NEDElement *createNodeWithTag(int tagcode);
};

#endif

---