itkDOMNode.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
 
#ifndef itkDOMNode_h
#define itkDOMNode_h
 
#include "itkObject.h"
#include "itkObjectFactory.h"
#include "ITKIOXMLExport.h"
 
#include <string>
#include <vector>
#include <list>
#include <map>
 
namespace itk
{
 
class DOMTextNode; // forward declaration
 
class ITKIOXML_EXPORT DOMNode : public Object
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(DOMNode);
 
  using Self = DOMNode;
  using Superclass = Object;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(DOMNode, Object);
 
  using ChildrenListType = std::vector<DOMNode *>;
  using ConstChildrenListType = std::vector<const DOMNode *>;
 
  using AttributeKeyType = std::string;
  using AttributeValueType = std::string;
 
  using AttributeItemType = std::pair<const AttributeKeyType, AttributeValueType>;
 
  using AttributesListType = std::list<AttributeItemType>;
 
  using SizeType = std::size_t;
  using IdentifierType = int;
  using OffsetType = int;
 
  virtual void
  SetParent(DOMNode * node);
  DOMNode *
  GetParent();
  const DOMNode *
  GetParent() const;
 
  itkSetMacro(Name, std::string &);
  itkGetConstReferenceMacro(Name, std::string);
 
  itkSetMacro(ID, std::string &);
  itkGetConstReferenceMacro(ID, std::string);
 
  virtual std::string
  GetAttribute(const std::string & key) const;
 
  virtual bool
  HasAttribute(const std::string & key) const;
 
  virtual void
  SetAttribute(const std::string & key, const std::string & value);
 
  virtual void
  RemoveAttribute(const std::string & key);
 
  virtual void
  GetAllAttributes(AttributesListType & output, bool keepOriginalOrder = true) const;
 
  virtual void
  RemoveAllAttributes();
 
  virtual SizeType
  GetNumberOfChildren() const;
 
  virtual void
  GetAllChildren(ChildrenListType & output);
 
  virtual void
  GetAllChildren(ConstChildrenListType & output) const;
 
  virtual void
  GetChildren(const std::string & tag, ChildrenListType & output);
 
  virtual void
  GetChildren(const std::string & tag, ConstChildrenListType & output) const;
 
  virtual void
  RemoveAllChildren();
 
  virtual void
  AddChild(DOMNode * node, IdentifierType i = 0);
 
  virtual void
  AddChildAtBegin(DOMNode * node);
 
  virtual void
  AddChildAtEnd(DOMNode * node);
 
  virtual void
  SetChild(DOMNode * node, IdentifierType i = 0);
 
  virtual void
  RemoveChild(IdentifierType i = 0);
 
  virtual void
  RemoveAllAttributesAndChildren();
 
  virtual DOMNode *
  GetChild(IdentifierType i = 0);
  virtual const DOMNode *
  GetChild(IdentifierType i = 0) const;
 
  virtual DOMNode *
  GetChild(const std::string & tag, IdentifierType i = 0);
  virtual const DOMNode *
  GetChild(const std::string & tag, IdentifierType i = 0) const;
 
  virtual DOMNode *
  GetChildByID(const std::string & value);
  virtual const DOMNode *
  GetChildByID(const std::string & value) const;
 
  virtual DOMNode *
  GetSibling(OffsetType i);
  virtual const DOMNode *
  GetSibling(OffsetType i) const;
 
  virtual DOMNode *
  GetRoot();
  virtual const DOMNode *
  GetRoot() const;
 
  virtual bool
  ShareRoot(const DOMNode * node) const;
 
  virtual DOMNode *
  Find(const std::string & path);
  virtual const DOMNode *
  Find(const std::string & path) const;
 
  virtual std::string
  GetPath() const;
 
  virtual DOMTextNode *
  GetTextChild(IdentifierType i = 0);
  virtual const DOMTextNode *
  GetTextChild(IdentifierType i = 0) const;
 
  virtual void
  AddTextChild(const std::string & text, IdentifierType i = 0);
 
  virtual void
  AddTextChildAtBegin(const std::string & text);
 
  virtual void
  AddTextChildAtEnd(const std::string & text);
 
  virtual void
  SetTextChild(const std::string & text, IdentifierType i = 0);
 
protected:
  DOMNode();
 
private:
  DOMNode * m_Parent{ nullptr };
 
  std::string m_Name;
 
  std::string m_ID;
 
  using ChildrenContainer = std::vector<Pointer>;
  ChildrenContainer m_Children;
 
  using AttributesContainer = std::map<AttributeKeyType, AttributeValueType>;
  AttributesContainer m_Attributes;
 
  using OrderedAttributesContainer = std::list<AttributeItemType *>;
  OrderedAttributesContainer m_OrderedAttributes;
};
 
} // namespace itk
 
#include "itkDOMTextNode.h"
 
#include "itkStringTools.h"
#include "itkFancyString.h"
 
#endif // itkDOMNode_h