itkTreeIteratorBase.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkTreeIteratorBase.h,v $
  Language:  C++
  Date:      $Date: 2009-06-14 11:55:05 $
  Version:   $Revision: 1.13 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkTreeIteratorBase_h
#define __itkTreeIteratorBase_h

#include <itkTreeNode.h>

namespace itk {

template <class TTreeType>
class TreeIteratorBase
{
public: 
  
  typedef TreeIteratorBase                    Self;
  typedef typename TTreeType::ValueType       ValueType;
  typedef typename TTreeType::TreeNodeType    TreeNodeType;

  virtual bool Add(ValueType element);

  virtual bool Add(int position, ValueType element);

  virtual bool Add(TTreeType& subTree);

  virtual const ValueType& Get() const;

  virtual TTreeType* GetSubTree() const;

  virtual bool IsLeaf() const;
  
  virtual bool IsRoot() const;

  virtual int GetType() const = 0;

  virtual bool GoToChild(int number = 0);
  
  virtual bool GoToParent( );

  void Set(ValueType element);

  virtual bool HasChild(int number = 0) const;

  virtual int ChildPosition(ValueType element) const;

  virtual bool RemoveChild(int number);

  virtual int CountChildren() const;

  virtual bool HasParent() const;

  virtual bool Disconnect();

  virtual TreeIteratorBase<TTreeType>* Children();

  virtual TreeIteratorBase<TTreeType>* Parents();

  virtual TreeIteratorBase<TTreeType>* GetChild(int number) const;

  virtual int Count();

  bool Remove();

  virtual TreeNodeType* GetNode();
  virtual const TreeNodeType* GetNode() const;

  TreeNodeType* GetRoot();
  const TreeNodeType* GetRoot() const;
  
  TTreeType* GetTree() const;

  const TreeNodeType* GetParent() const;

  void GoToBegin()
    {
    m_Position = m_Begin;
    }

  void GoToEnd()
    {
    m_Position = m_End;
    }

  bool IsAtBegin(void) const
    {
    return (m_Position == m_Begin);
    }

  bool IsAtEnd(void) const
    {
    return (m_Position == m_End);
    }

  virtual TreeIteratorBase<TTreeType>* Clone() = 0;

  enum{
    UNDEFIND   = 0,
    PREORDER   = 1,
    INORDER    = 2,
    POSTORDER  = 3,
    LEVELORDER = 4,
    CHILD   = 5,
    ROOT     = 6,
    LEAF     = 7
  };

  Self &
  operator++()
    {
    this->Next();
    return *this;
    }
  void
  operator++(int)
    {
    // assert( !IsAtEnd() );
    this->Next();
    }
  const Self & operator=(const Self& iterator) 
    {
    m_Position = iterator.m_Position; 
    m_Begin  = iterator.m_Begin;
    m_End = iterator.m_End;
    m_Root = iterator.m_Root;
    m_Tree = iterator.m_Tree;
    return *this;
    }

  virtual ~TreeIteratorBase() {}
  
protected:

  TreeIteratorBase( TTreeType* tree, const TreeNodeType* start);
  TreeIteratorBase( const TTreeType* tree, const TreeNodeType* start);

  mutable TreeNodeType* m_Position; // Current position of the iterator
  mutable TreeNodeType* m_Begin;
  mutable TreeNodeType* m_End;
  const TreeNodeType*   m_Root;
  TTreeType*            m_Tree;

  virtual bool HasNext() const = 0;
  virtual const ValueType& Next() = 0;
};

} //end namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_TreeIteratorBase(_, EXPORT, x, y) namespace itk { \
  _(1(class EXPORT TreeIteratorBase< ITK_TEMPLATE_1 x >)) \
  namespace Templates { typedef TreeIteratorBase< ITK_TEMPLATE_1 x > \
                                                  TreeIteratorBase##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkTreeIteratorBase+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkTreeIteratorBase.txx"
#endif

#endif