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 <string>
#include <vector>
#include <list>
#include <map>

namespace itk
{

class DOMTextNode; // forward declaration

class DOMNode : public Object
{
public:

  typedef DOMNode                     Self;
  typedef Object                      Superclass;
  typedef SmartPointer< Self >        Pointer;
  typedef SmartPointer< const Self >  ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(DOMNode, Object);

  typedef std::vector<DOMNode*>         ChildrenListType;
  typedef std::vector<const DOMNode*>   ConstChildrenListType;

  typedef std::string AttributeKeyType;
  typedef std::string AttributeValueType;

  typedef std::pair<const AttributeKeyType,AttributeValueType> AttributeItemType;

  typedef std::list<AttributeItemType> AttributesListType;

  typedef std::size_t SizeType;
  typedef int         IdentifierType;
  typedef int         OffsetType;

  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;

  std::string m_Name;

  std::string m_ID;

  typedef std::vector<Pointer> ChildrenContainer;
  ChildrenContainer m_Children;

  typedef std::map<AttributeKeyType,AttributeValueType> AttributesContainer;
  AttributesContainer m_Attributes;

  typedef std::list<AttributeItemType*> OrderedAttributesContainer;
  OrderedAttributesContainer m_OrderedAttributes;

  DOMNode(const Self &); //purposely not implemented
  void operator=(const Self &); //purposely not implemented
};

} // namespace itk

#include "itkDOMTextNode.h"

#include "itkStringTools.h"
#include "itkFancyString.h"

#endif // __itkDOMNode_h