itkDOMNode.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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_ASSIGN(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