aterm_appl_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_DETAIL_ATERM_APPL_ITERATOR_H
#define MCRL2_ATERMPP_DETAIL_ATERM_APPL_ITERATOR_H
 
#include "mcrl2/atermpp/detail/aterm.h"
 
namespace atermpp
{
 
template <typename Term>
class term_appl_iterator
{
    friend class aterm;
 
    template < class Derived, class Base >
    friend term_appl_iterator<Derived> detail::aterm_appl_iterator_cast(term_appl_iterator<Base> a,
                                                                typename std::enable_if<
                                                                     std::is_base_of<aterm, Base>::value &&
                                                                     std::is_base_of<aterm, Derived>::value
                                                                >::type*);
 
 
  protected:
    const Term* m_term;
    
    term_appl_iterator(const Term* t)
      : m_term(t)
    {}
 
  public:
    typedef Term value_type;
    typedef const Term& reference;
    typedef const Term* pointer;
    typedef ptrdiff_t difference_type;
    typedef std::random_access_iterator_tag iterator_category;
 
    term_appl_iterator(const term_appl_iterator& other)
      : m_term(other.m_term)
    {}
 
    term_appl_iterator& operator=(const term_appl_iterator& other)
    {
      m_term=other.m_term;
      return *this;
    }
    
    const Term& operator*() const
    {
      return *m_term;
    }
 
    const Term* operator->() const
    {
      return m_term;
    }
 
    const Term& operator[](difference_type n) const
    {
      return *(m_term+n);
    }
 
    term_appl_iterator& operator++()
    {
      ++m_term;
      return *this;
    }
 
    term_appl_iterator operator++(int)
    {
      term_appl_iterator temp=*this;
      ++m_term;
      return temp;
    }
 
    term_appl_iterator& operator--()
    {
      --m_term;
      return *this;
    }
 
    term_appl_iterator operator--(int)
    {
      term_appl_iterator temp=*this;
      --m_term;
      return *this;
    }
 
    term_appl_iterator& operator+=(difference_type n)
    {
      m_term+=n;
      return *this;
    }
 
    term_appl_iterator& operator-=(difference_type n)
    {
      m_term-=n;
      return *this;
    }
 
    term_appl_iterator operator+(ptrdiff_t n) const
    {
      term_appl_iterator temp=*this;
      return temp.m_term+n;
    }
 
    term_appl_iterator operator-(ptrdiff_t n) const
    {
      term_appl_iterator temp=*this;
      return temp.m_term-n;
    }
 
    ptrdiff_t operator-(const term_appl_iterator& other) const
    {
      return m_term-other.m_term;
    }
 
    ptrdiff_t distance_to(const term_appl_iterator& other) const
    {
      return other.m_term-m_term;
    }
 
 
    bool operator ==(const term_appl_iterator& other) const
    {
      return m_term == other.m_term;
    }
 
    bool operator !=(const term_appl_iterator& other) const
    {
      return m_term != other.m_term;
    }
 
    bool operator <(const term_appl_iterator& other) const
    {
      return m_term < other.m_term;
    }
 
    bool operator <=(const term_appl_iterator& other) const
    {
      return m_term <= other.m_term;
    }
 
    bool operator >(const term_appl_iterator& other) const
    {
      return m_term > other.m_term;
    }
 
    bool operator >=(const term_appl_iterator& other) const
    {
      return m_term >= other.m_term;
    }
};
 
namespace detail
{
  template < class Derived, class Base >
  term_appl_iterator<Derived> aterm_appl_iterator_cast(term_appl_iterator<Base> a,
                                                       typename std::enable_if<
                                                                     std::is_base_of<aterm, Base>::value &&
                                                                     std::is_base_of<aterm, Derived>::value
                                                                >::type* /* = nullptr */)
  {
    static_assert(sizeof(Derived) == sizeof(_aterm*),
                "term_appl_iterator only works on aterm classes to which no extra fields are added");
    static_assert(sizeof(Base) == sizeof(_aterm*),
                "term_appl_iterator only works on aterm classes to which no extra fields are added");
    return term_appl_iterator<Derived>(reinterpret_cast<const Derived*>(a.m_term));
  }
 
} // namespace detail
 
} // namespace atermpp
 
#endif // MCRL2_ATERMPP_DETAIL_ATERM_APPL_ITERATOR_H