itkTreeIteratorBase.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 __itkTreeIteratorBase_h
#define __itkTreeIteratorBase_h

#include "itkTreeNode.h"

namespace itk
{
template< typename TTreeType >
class TreeIteratorBase
{
public:

  typedef TreeIteratorBase                       Self;
  typedef typename TTreeType::ValueType          ValueType;
  typedef typename TTreeType::TreeNodeType       TreeNodeType;
  typedef typename TreeNodeType::ChildIdentifier ChildIdentifier;

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

  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 NodeType GetType() const = 0;

  virtual bool GoToChild(ChildIdentifier 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;

  Self &
  operator++()
  {
    this->Next();
    return *this;
  }

  void
  operator++(int)
  {
    // itkAssertInDebugAndIgnoreInReleaseMacro( !IsAtEnd() );
    this->Next();
  }

  Self & operator=(const Self & iterator)
  {
    if(this != &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

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTreeIteratorBase.hxx"
#endif

#endif