aterm_list_iterator.h

Go to the documentation of this file.

// Author(s): Jan Friso Groote, Wieger Wesselink
// Copyright: see the accompanying file COPYING or copy at
// https://github.com/mCRL2org/mCRL2/blob/master/COPYING
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef MCRL2_ATERMPP_ATERM_LIST_ITERATOR_H
#define MCRL2_ATERMPP_ATERM_LIST_ITERATOR_H
 
#include "mcrl2/atermpp/detail/global_aterm_pool.h"
 
namespace atermpp
{
 
namespace detail
{
  template <class Term>
  class _aterm_list;
}
 
 
template <typename Term>
class term_list_iterator 
{
    template<class T>
    friend class term_list;
 
  protected:
    const detail::_aterm_list<Term>* m_list;
 
    term_list_iterator(const detail::_aterm* l)
      : m_list(static_cast<const detail::_aterm_list<Term>*>(l))
    { 
      assert(l->function()==detail::g_term_pool().as_list()
             || l->function()==detail::g_term_pool().as_empty_list());
    } 
 
  public:
    typedef Term value_type;
    typedef Term& reference;
    typedef Term* pointer;
    typedef ptrdiff_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
 
    term_list_iterator()
      : m_list(nullptr)
    {}
 
    term_list_iterator(const term_list_iterator& other)
      : m_list(other.m_list)
    { 
    } 
 
    term_list_iterator& operator=(const term_list_iterator& other)
    { 
      m_list=other.m_list;
      return *this;
    } 
 
    const Term& operator*() const
    {
      assert(m_list->function()==detail::g_term_pool().as_list());
      return m_list->head();
    }
 
    const Term* operator->() const
    {
      assert(m_list->function()==detail::g_term_pool().as_list());
      return &m_list->head();
    }
    
    term_list_iterator& operator++()
    {
      assert(m_list->function() == detail::g_term_pool().as_list());
      m_list = static_cast<detail::_aterm_list<Term>*>(detail::address(m_list->tail()));
      return *this;
    }
 
    term_list_iterator operator++(int)
    {
      assert(m_list->function() == detail::g_term_pool().as_list());
      const term_list_iterator temp = *this;
      m_list = static_cast<detail::_aterm_list<Term>*>(detail::address(m_list->tail()));
      return temp;
    }
 
    bool operator ==(const term_list_iterator& other) const
    {
      return m_list == other.m_list;
    }
 
    bool operator !=(const term_list_iterator& other) const
    {
      return m_list != other.m_list;
    }
 
    bool operator <(const term_list_iterator& other) const
    {
      return m_list < other.m_list;
    }
 
    bool operator <=(const term_list_iterator& other) const
    {
      return m_list <= other.m_list;
    }
 
    bool operator >(const term_list_iterator& other) const
    {
      return m_list > other.m_list;
    }
 
    bool operator >=(const term_list_iterator& other) const
    {
      return m_list >= other.m_list;
    }
 
};
 
template <typename Term>
class reverse_term_list_iterator 
{
    template<class T>
    friend class term_list;
 
  protected:
    std::size_t m_position;   // m_position refers one above the position to be deliverd. 
    std::unique_ptr<detail::_aterm_list<Term> const*[]> m_list_element_references;
 
    reverse_term_list_iterator(detail::_aterm const* l)
      : m_position(reinterpret_cast<const detail::_aterm_list<Term>*>(l)->size()),
        m_list_element_references((m_position==0?nullptr:new typename detail::_aterm_list<Term> const*[m_position]))
    { 
      assert(l->function()==detail::g_term_pool().as_list()
             || l->function()==detail::g_term_pool().as_empty_list());
      std::size_t j=0;
      for(detail::_aterm_list<Term> const* t=reinterpret_cast<detail::_aterm_list<Term> const*>(l); 
              t->function()==detail::g_term_pool().as_list(); 
              t=reinterpret_cast<detail::_aterm_list<Term> const*>(detail::address(t->tail())), j++)
      {
        m_list_element_references[j]=t;
      }
    } 
 
  public:
    typedef Term value_type;
    typedef Term& reference;
    typedef Term* pointer;
    typedef ptrdiff_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
 
    reverse_term_list_iterator()
      : m_position(0),
        m_list_element_references(nullptr)
    {
    }
 
    reverse_term_list_iterator(const reverse_term_list_iterator& other) = delete;
 
    reverse_term_list_iterator& operator=(const reverse_term_list_iterator& other) = delete;
 
    const Term& operator*() const
    {
      assert(m_list_element_references[m_position-1]->function()==detail::g_term_pool().as_list());
      return m_list_element_references[m_position-1]->head();
    }
 
    const Term* operator->() const
    {
      assert(m_list_element_references[m_position-1]->function()==detail::g_term_pool().as_list());
      return &(m_list_element_references[m_position-1]->head());
    }
    
    reverse_term_list_iterator& operator++()
    {
      assert(m_list_element_references[m_position-1]->function() == detail::g_term_pool().as_list());
      m_position--;
      return *this;
    }
 
    void operator++(int)
    {
      assert(m_list_element_references[m_position-1]->function() == detail::g_term_pool().as_list());
      m_position--;
    }
 
    bool operator ==(const reverse_term_list_iterator& other) const
    {
      return m_position == other.m_position;
    }
 
    bool operator !=(const reverse_term_list_iterator& other) const
    {
      return !(*this == other);
    }
 
    bool operator <(const reverse_term_list_iterator& other) const
    {
      return m_position < other.position;
    }
 
    bool operator <=(const reverse_term_list_iterator& other) const
    {
      return m_position <= other.m_position;
    }
 
    bool operator >(const reverse_term_list_iterator& other) const
    {
      return m_position > other.m_position;
    }
 
    bool operator >=(const reverse_term_list_iterator& other) const
    {
      return m_position >= other.m_position;
    }
 
};
 
} // namespace atermpp
 
#endif // MCRL2_ATERMPP_ATERM_LIST_ITERATOR_H