spatial_bidirectional.hpp

// -*- C++ -*-
//
// Copyright Sylvain Bougerel 2009 - 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file COPYING or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef SPATIAL_BIDIRECTIONAL_HPP
#define SPATIAL_BIDIRECTIONAL_HPP

#include "spatial_node.hpp"

namespace spatial
{
  namespace details
  {
    template <typename Link, typename Rank>
    class Bidirectional_iterator : private Rank
    {
    public:
      typedef typename mutate<typename Link::value_type>::type value_type;
      typedef typename Link::value_type&           reference;
      typedef typename Link::value_type*           pointer;
      typedef std::ptrdiff_t                       difference_type;
      typedef std::bidirectional_iterator_tag      iterator_category;
      typedef typename Link::node_ptr              node_ptr;
      typedef Rank                                 rank_type;
      typedef typename Link::invariant_category    invariant_category;

      Bidirectional_iterator() { }

      Bidirectional_iterator(const Rank& rank_, node_ptr node_,
                             dimension_type node_dim_)
        : Rank(rank_), node(node_), node_dim(node_dim_) { }

      reference operator*()
      { return value(node); }

      pointer operator->()
      { return &value(node); }

      bool operator==(const Const_node_iterator<Link>& x) const
      { return node == x.node; }

      bool operator!=(const Const_node_iterator<Link>& x) const
      { return node != x.node; }


      operator Node_iterator<Link>() const
      { return Node_iterator<Link>(node); }

      operator Const_node_iterator<Link>() const
      { return Const_node_iterator<Link>(node); }

      const rank_type& rank() const { return static_cast<const Rank&>(*this); }

      dimension_type dimension() const
      { return static_cast<const Rank&>(*this)(); }

      node_ptr node;

      dimension_type node_dim;
    };

    template <typename Link, typename Rank>
    class Const_bidirectional_iterator : private Rank
    {
    public:
      typedef typename mutate<typename Link::value_type>::type value_type;
      typedef const typename Link::value_type&     reference;
      typedef const typename Link::value_type*     pointer;
      typedef std::ptrdiff_t                       difference_type;
      typedef std::bidirectional_iterator_tag      iterator_category;
      typedef typename Link::const_node_ptr        node_ptr;
      typedef Rank                                 rank_type;
      typedef typename Link::invariant_category    invariant_category;

      Const_bidirectional_iterator() { }

      Const_bidirectional_iterator(const Rank& rank_, node_ptr node_,
                                   dimension_type node_dim_)
        : Rank(rank_), node(node_), node_dim(node_dim_) { }

      reference operator*()
      { return const_value(node); }

      pointer operator->()
      { return &const_value(node); }

      bool operator==(const Const_node_iterator<Link>& x) const
      { return node == x.node; }

      bool operator!=(const Const_node_iterator<Link>& x) const
      { return node != x.node; }

      operator Const_node_iterator<Link>() const
      { return Const_node_iterator<Link>(node); }

      rank_type rank() const { return static_cast<const Rank>(*this); }

      dimension_type dimension() const
      { return static_cast<const Rank&>(*this)(); }

      node_ptr node;

      dimension_type node_dim;
    };

  } // namespace details
} // namespace spatial

#endif // SPATIAL_BIDIRECTIONAL_HPP