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
{
enum class TreeIteratorBaseNodeEnum : uint8_t
{
  UNDEFIND = 0,
  PREORDER = 1,
  INORDER = 2,
  POSTORDER = 3,
  LEVELORDER = 4,
  CHILD = 5,
  ROOT = 6,
  LEAF = 7
};
 
template <typename TTreeType>
class ITK_TEMPLATE_EXPORT TreeIteratorBase
{
public:
  using Self = TreeIteratorBase;
  using ValueType = typename TTreeType::ValueType;
  using TreeNodeType = typename TTreeType::TreeNodeType;
  using ChildIdentifier = typename TreeNodeType::ChildIdentifier;
 
  using NodeType = TreeIteratorBaseNodeEnum;
#if !defined(ITK_LEGACY_REMOVE)
  // We need to expose the enum values at the class level
  // for backwards compatibility
  static constexpr NodeType UNDEFIND = NodeType::UNDEFIND;
  static constexpr NodeType PREORDER = NodeType::PREORDER;
  static constexpr NodeType INORDER = NodeType::INORDER;
  static constexpr NodeType POSTORDER = NodeType::POSTORDER;
  static constexpr NodeType LEVELORDER = NodeType::LEVELORDER;
  static constexpr NodeType CHILD = NodeType::CHILD;
  static constexpr NodeType ROOT = NodeType::ROOT;
  static constexpr NodeType LEAF = NodeType::LEAF;
#endif
 
  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 = nullptr;
  }
 
  bool
  IsAtBegin() const
  {
    return (m_Position == m_Begin);
  }
 
  bool
  IsAtEnd() const
  {
    return (m_Position == nullptr);
  }
 
  virtual TreeIteratorBase<TTreeType> *
  Clone() = 0;
 
  Self &
  operator++()
  {
    this->Next();
    return *this;
  }
 
  void
  operator++(int)
  {
    this->Next();
  }
 
  Self &
  operator=(const Self & iterator)
  {
    if (this != &iterator)
    {
      m_Position = iterator.m_Position;
      m_Begin = iterator.m_Begin;
      m_Root = iterator.m_Root;
      m_Tree = iterator.m_Tree;
    }
    return *this;
  }
 
  virtual ~TreeIteratorBase() = default;
 
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;
  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