cxmlelement.h

//==========================================================================
//  CXMLELEMENT.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 2002-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_CXMLELEMENT_H
#define __OMNETPP_CXMLELEMENT_H
 
#include <string>
#include <map>
#include <vector>
#include "simkerneldefs.h"
#include "cenvir.h"
#include "fileline.h"
#include "opp_pooledstring.h"
 
namespace omnetpp {
 
class cXMLElement;
class cModule;
 
typedef std::vector<cXMLElement*> cXMLElementList;
 
typedef std::map<std::string,std::string> cXMLAttributeMap;
 
 
class SIM_API cXMLElement : public cOwnedObject
{
    friend class cXMLElementDescriptor; // getAttr(i), getChild(i), etc.
 
  public:
    class SIM_API ParamResolver
    {
      public:
        virtual bool resolve(const char *paramname, std::string& value) = 0;
        virtual ~ParamResolver() {}
    };
 
  private:
    opp_pooledstring value;
    typedef std::pair<opp_pooledstring,opp_pooledstring> Attr;
    std::vector<Attr> attrs;
    cXMLElement *parent = nullptr;
    cXMLElement *firstChild = nullptr;
    cXMLElement *lastChild = nullptr;
    cXMLElement *prevSibling = nullptr;
    cXMLElement *nextSibling = nullptr;
    FileLine loc;
 
  private:
     void doGetElementsByTagName(const char *tagname, cXMLElementList& list) const;
 
  public:
    // internal: constructor
    cXMLElement(const char *tagname, cXMLElement *parent=nullptr);
 
    // internal: constructor - for backward compatibility
    cXMLElement(const char *tagname, const char *ignored, cXMLElement *parent) : cXMLElement(tagname, parent) {}
 
    // internal: copy constructor
    cXMLElement(const cXMLElement& other);
 
    // internal: Destructor. Destroys children too.
    virtual ~cXMLElement();
 
    // internal: creates and returns an exact copy of this object. Child nodes are not duplicated.
    virtual cXMLElement *dup() const override  {return new cXMLElement(*this);}
 
    virtual cXMLElement *dupTree() const;
 
    virtual void setTagName(const char *tagName) {setName(tagName);}
 
    // internal: sets source location
    virtual void setSourceLocation(const char *fname, int line);
 
    // internal: sets text node within element
    virtual void setNodeValue(const char *s);
 
    // internal: sets text node within element
    virtual void setNodeValue(const char *s, int len);
 
    // internal: appends to text node within element
    virtual void appendNodeValue(const char *s, int len);
 
    // internal: Sets the value of the attribute with the given name.
    virtual void setAttribute(const char *attr, const char *value);
 
    // internal: Set attributes of the element: name,value,name,value,...,nullptr
    virtual void setAttributes(const char **attrs);
 
    // internal: Appends the given element at the end of the child element list.
    virtual void appendChild(cXMLElement *node);
 
    // internal: Inserts the given element just before the specified child element
    // in the child element list. The where element must be a child of this element.
    virtual void insertChildBefore(cXMLElement *where, cXMLElement *newnode);
 
    // internal: Removes the given element from the child element list.
    // The pointer passed should be a child of this element.
    virtual cXMLElement *removeChild(cXMLElement *node);
 
    // internal: matches from root element
    static cXMLElement *getDocumentElementByPath(cXMLElement *documentnode, const char *pathexpr, ParamResolver *resolver=nullptr);
 
  private:
    // internal
    Attr *findAttr(const char *name) const;
    void addAttr(const char *name, const char *value);
    virtual void print(std::ostream& os, int indentLevel) const;
 
    // internal, for inspectors only; O(n) complexity!
    int getNumAttrs() const;
    const char *getAttrName(int index) const;
    const char *getAttrValue(int index) const;
    std::string getAttrDesc(int index) const;
    int getNumChildren() const;
    cXMLElement *getChild(int index) const;
 
  public:
    virtual std::string str() const override;
 
    virtual void forEachChild(cVisitor *v) override;
 
 
    virtual const char *getTagName() const {return getName();}
 
    virtual const char *getSourceFileName() const {return loc.getFilename();}
 
    virtual int getSourceLineNumber() const {return loc.getLineNumber();}
 
    virtual const char *getSourceLocation() const;
 
    virtual const char *getNodeValue() const;
 
    virtual const char *getAttribute(const char *attr) const;
 
    virtual bool hasAttributes() const;
 
    virtual cXMLAttributeMap getAttributes() const;
 
    virtual std::string getXML() const;
 
    virtual cXMLElement *getParentNode() const;
 
    virtual bool hasChildren() const;
 
    virtual cXMLElement *getFirstChild() const;
 
    virtual cXMLElement *getLastChild() const;
 
    virtual cXMLElement *getNextSibling() const;
 
    virtual cXMLElement *getPreviousSibling() const;
 
    virtual cXMLElement *getFirstChildWithTag(const char *tagname) const;
 
    virtual cXMLElement *getNextSiblingWithTag(const char *tagname) const;
 
    virtual cXMLElementList getChildren() const;
 
    virtual cXMLElementList getChildrenByTagName(const char *tagname) const;
 
    virtual cXMLElementList getElementsByTagName(const char *tagname) const;
 
    virtual cXMLElement *getFirstChildWithAttribute(const char *tagname, const char *attr, const char *attrvalue=nullptr) const;
 
    virtual cXMLElement *getElementById(const char *idattrvalue) const;
 
    virtual cXMLElement *getElementByPath(const char *pathexpression, cXMLElement *root=nullptr, ParamResolver *resolver=nullptr) const;
};
 
class SIM_API ModNameParamResolver : public cXMLElement::ParamResolver
{
  protected:
    cModule *mod;
  public:
    ModNameParamResolver(cModule *mod)  {this->mod = mod;}
    virtual bool resolve(const char *paramname, std::string& value) override;
};
 
class SIM_API StringMapParamResolver : public cXMLElement::ParamResolver
{
  public:
    typedef std::map<std::string,std::string> StringMap;
  protected:
    StringMap params;
  public:
    StringMapParamResolver(const StringMap& m)  {params = m;}
    virtual bool resolve(const char *paramname, std::string& value) override;
};
 
}  // namespace omnetpp
 
 
#endif