aterm_list.h

Go to the documentation of this file.

// Author(s): Wieger Wesselink, Jan Friso Groote
// 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_H
#define MCRL2_ATERMPP_ATERM_LIST_H
 
#include "mcrl2/atermpp/aterm.h"
#include "mcrl2/atermpp/detail/aterm_list.h"
#include "mcrl2/atermpp/detail/aterm_list_iterator.h"
#include "mcrl2/atermpp/type_traits.h"
 
namespace atermpp
{
 
template <typename Term>
class term_list: public aterm
{
protected:
  explicit term_list(detail::_aterm_appl<>* t) noexcept : aterm(t)
  {
    assert(!defined() || type_is_list());
  }
 
public:
  typedef Term value_type;
 
  typedef Term* pointer;
 
  typedef Term& reference;
 
  typedef const Term& const_reference;
 
  typedef std::size_t size_type;
 
  typedef ptrdiff_t difference_type;
 
  typedef term_list_iterator<Term> iterator;
 
  typedef term_list_iterator<Term> const_iterator;
 
  typedef reverse_term_list_iterator<Term> const_reverse_iterator;
 
  term_list() noexcept
    : aterm(detail::g_term_pool().empty_list())
  {}
 
  explicit term_list(const aterm& t) noexcept
    : aterm(t)
  {
    // assert(!defined() || type_is_list());
    assert(type_is_list());  // A list should not be a default aterm. 
  }
 
  term_list(const term_list<Term>& t) noexcept
    : aterm(t)
  {
    assert(!defined() || type_is_list());
  }
 
  term_list(term_list<Term>&& t) noexcept
    : aterm(std::move(t))
  {
    assert(!defined() || type_is_list());
  }
 
  term_list& operator=(const term_list& other) noexcept = default;
  term_list& operator=(term_list&& other) noexcept = default;
 
  template <class Iter>
  explicit term_list(Iter first, Iter last, typename std::enable_if<std::is_base_of<
                std::bidirectional_iterator_tag,
                typename std::iterator_traits<Iter>::iterator_category
            >::value>::type* = nullptr) :
      aterm(detail::make_list_backward<Term,Iter,
                detail::do_not_convert_term<Term> >(first, last,detail::do_not_convert_term<Term>()))
  {
    assert(!defined() || type_is_list());
  }
 
  template <class Iter, class ATermConverter>
  explicit term_list(Iter first, Iter last, const ATermConverter& convert_to_aterm,
            typename std::enable_if<std::is_base_of<
              std::bidirectional_iterator_tag,
              typename std::iterator_traits<Iter>::iterator_category
            >::value>::type* = 0):
       aterm(detail::make_list_backward<Term,Iter,ATermConverter>(first, last, convert_to_aterm))
  {
    assert(!defined() || type_is_list());
  }
 
  template <class Iter, class ATermConverter, class ATermFilter>
  explicit term_list(Iter first, Iter last, const ATermConverter& convert_to_aterm, const ATermFilter& aterm_filter,
            typename std::enable_if<std::is_base_of<
              std::bidirectional_iterator_tag,
              typename std::iterator_traits<Iter>::iterator_category
            >::value>::type* = 0):
       aterm(detail::make_list_backward<Term,Iter,ATermConverter,ATermFilter>(first, last, convert_to_aterm, aterm_filter))
  {
    assert(!defined() || type_is_list());
  }
 
  template <class Iter>
  explicit term_list(Iter first, Iter last,
                     typename std::enable_if< !std::is_base_of<
                       std::bidirectional_iterator_tag,
                       typename std::iterator_traits<Iter>::iterator_category
                     >::value>::type* = nullptr):
       aterm(detail::make_list_forward<Term,Iter,detail::do_not_convert_term<Term> >
                               (first, last, detail::do_not_convert_term<Term>()))
  {
    assert(!defined() || type_is_list());
  }
 
  template <class Iter, class  ATermConverter>
  explicit term_list(Iter first, Iter last, const ATermConverter& convert_to_aterm,
                     typename std::enable_if< !std::is_base_of<
                       std::bidirectional_iterator_tag,
                       typename std::iterator_traits<Iter>::iterator_category
                     >::value>::type* = nullptr):
       aterm(detail::make_list_forward<Term,Iter,ATermConverter>
                               (first, last, convert_to_aterm))
  {
    assert(!defined() || type_is_list());
  }
 
  template <class Iter, class  ATermConverter, class ATermFilter>
  explicit term_list(Iter first, Iter last, const ATermConverter& convert_to_aterm, const ATermFilter& aterm_filter,
                     typename std::enable_if< !std::is_base_of<
                       std::random_access_iterator_tag,
                       typename std::iterator_traits<Iter>::iterator_category
                     >::value>::type* = nullptr):
       aterm(detail::make_list_forward<Term,Iter,ATermConverter>
                               (first, last, convert_to_aterm, aterm_filter))
  {
    assert(!defined() || type_is_list());
  }
 
  term_list(std::initializer_list<Term> init)
    : aterm(detail::make_list_backward<Term,
                                       typename std::initializer_list<Term>::const_iterator,
                                       detail::do_not_convert_term<Term> >
                (init.begin(), init.end(), detail::do_not_convert_term<Term>()))
  {
    assert(!defined() || type_is_list());
  }
 
  const term_list<Term>& tail() const
  {
    assert(!empty());
    return (static_cast<const detail::_aterm_list<Term>&>(*m_term)).tail();
  }
 
  void pop_front()
  {
    *this = tail();
  }
 
  const Term& front() const
  {
    return static_cast<const detail::_aterm_list<Term>&>(*m_term).head();
  }
 
  void push_front(const Term& el);
 
  template<typename ...Args>
  void emplace_front(Args&&... arguments);
 
  size_type size() const
  {
    std::size_t size=0;
    for(const_iterator i=begin(); i!=end(); ++i)
    {
      ++size;
    }
    return size;
  }
 
  bool empty() const
  {
    return m_term->function() == detail::g_term_pool().as_empty_list();
  }
 
  const_iterator begin() const
  {
    return const_iterator(m_term);
  }
 
  const_iterator end() const
  {
    return const_iterator(detail::address(detail::g_term_pool().empty_list()));
  }
 
  const_reverse_iterator rbegin() const
  {
    return const_reverse_iterator(m_term);
  }
 
  const_reverse_iterator rend() const
  {
    return const_reverse_iterator();
  }
 
  size_type max_size() const
  {
    return std::numeric_limits<std::size_t>::max();
  }
};
 
 
template <class Term>
void make_term_list(term_list<Term>& target)
{
  target=atermpp::down_cast<term_list<Term>>(detail::g_term_pool().empty_list());
}
 
template <class Term, class Iter>
void make_term_list(term_list<Term>& target, Iter first, Iter last, typename std::enable_if<std::is_base_of<
                                         std::bidirectional_iterator_tag,
                                         typename std::iterator_traits<Iter>::iterator_category >::value>::type* = nullptr)
{
  detail::make_list_backward<Term,Iter,
              detail::do_not_convert_term<Term> >(target, first, last,detail::do_not_convert_term<Term>());
  assert(!target.defined() || target.type_is_list());
}
 
template <class Term, class Iter, class ATermConverter>
void make_term_list(term_list<Term>& target, Iter first, Iter last, const ATermConverter& convert_to_aterm,
                            typename std::enable_if<std::is_base_of<
                              std::bidirectional_iterator_tag,
                              typename std::iterator_traits<Iter>::iterator_category
                            >::value>::type* = 0)
{
  detail::make_list_backward<Term,Iter,ATermConverter>(target, first, last, convert_to_aterm);
  assert(!target.defined() || target.type_is_list());
}
 
template <class Term, class Iter, class ATermConverter, class ATermFilter>
void make_term_list(term_list<Term>& target, Iter first, Iter last, const ATermConverter& convert_to_aterm, const ATermFilter& aterm_filter,
                            typename std::enable_if<std::is_base_of<
                              std::bidirectional_iterator_tag,
                              typename std::iterator_traits<Iter>::iterator_category
                            >::value>::type* = 0)
{
  detail::make_list_backward<Term,Iter,ATermConverter,ATermFilter>(target, first, last, convert_to_aterm, aterm_filter);
  assert(!target.defined() || target.type_is_list());
}
 
template <class Term, class Iter>
void make_term_list(term_list<Term>& target, Iter first, Iter last,
                             typename std::enable_if< !std::is_base_of<
                               std::bidirectional_iterator_tag,
                               typename std::iterator_traits<Iter>::iterator_category
                             >::value>::type* = nullptr)
{
  detail::make_list_forward<Term,Iter,detail::do_not_convert_term<Term> >
                             (target, first, last, detail::do_not_convert_term<Term>());
  assert(!target.defined() || target.type_is_list());
}
 
template <class Term, class Iter, class  ATermConverter>
void make_term_list(term_list<Term>& target, Iter first, Iter last, const ATermConverter& convert_to_aterm,
                              typename std::enable_if< !std::is_base_of<
                                std::bidirectional_iterator_tag,
                                typename std::iterator_traits<Iter>::iterator_category
                              >::value>::type* = nullptr)
{
  detail::make_list_forward<Term,Iter,ATermConverter>
                             (target, first, last, convert_to_aterm);
  assert(!target.defined() || target.type_is_list());
}
 
template <class Term, class Iter, class  ATermConverter, class ATermFilter>
void make_term_list(term_list<Term>& target, Iter first, Iter last, const ATermConverter& convert_to_aterm, const ATermFilter& aterm_filter,
                               typename std::enable_if< !std::is_base_of<
                                 std::random_access_iterator_tag,
                                 typename std::iterator_traits<Iter>::iterator_category
                               >::value>::type* = nullptr)
{
  detail::make_list_forward<Term,Iter,ATermConverter>
                             (target, first, last, convert_to_aterm, aterm_filter);
  assert(!target.defined() || target.type_is_list());
}
 
template <class Term>
void make_term_list(term_list<Term>& target, std::initializer_list<Term> init)
{
  target=detail::make_list_backward<Term,
                                    typename std::initializer_list<Term>::const_iterator,
                                    detail::do_not_convert_term<Term> >
              (init.begin(), init.end(), detail::do_not_convert_term<Term>());
  assert(!target.defined() || target.type_is_list());
}
 
 
 
namespace detail
{
 
template < typename T >
struct is_container_impl< atermpp::term_list< T > > : public std::true_type
{ };
 
 
template <class Term>
class _aterm_list : public _aterm_appl<2>
{
public:
  const Term& head() const { return static_cast<const Term&>(arg(0)); }
 
  const term_list<Term>& tail() const { return static_cast<const term_list<Term>&>(arg(1)); }
 
  std::size_t size() const
  {
    std::size_t size=0;
    for(_aterm_list const* i=this; 
        i->function()!=detail::g_term_pool().as_empty_list(); 
        i=static_cast<_aterm_list const*>(address(i->tail())))
    {
      ++size;
    }
    return size;
  }
 
};
 
} // namespace detail
 
 
typedef term_list<aterm> aterm_list;
 
 
template <typename Term>
inline
term_list<Term> reverse(const term_list<Term>& l);
 
template <typename Term>
inline
term_list<Term> sort_list(const term_list<Term>& l, 
                          const std::function<bool(const Term&, const Term&)>& ordering 
                                      = [](const Term& t1, const Term& t2){ return t1<t2;});
 
 
 
template <typename Term1, typename Term2>
inline
typename std::conditional<std::is_convertible<Term2,Term1>::value,term_list<Term1>,term_list<Term2>>::type
operator+(const term_list<Term1>& l, const term_list<Term2>& m);
 
 
template <typename Term>
inline
term_list<Term> push_back(const term_list<Term>& l, const Term& el);
 
template <typename T>
std::vector<T> as_vector(const atermpp::term_list<T>& x)
{
  return std::vector<T>(x.begin(), x.end());
}
 
template <typename T>
std::set<T> as_set(const atermpp::term_list<T>& x)
{
  return std::set<T>(x.begin(), x.end());
}
 
} // namespace atermpp
 
 
namespace std
{
//
template <class T>
inline void swap(atermpp::term_list<T>& t1, atermpp::term_list<T>& t2) noexcept
{
  t1.swap(t2);
}
 
template <class Term>
struct hash<atermpp::term_list<Term> >
{
  std::size_t operator()(const atermpp::term_list<Term>& l) const
  {
    std::hash<atermpp::aterm> hasher;
    return hasher(l);
  }
};
 
} // namespace std
 
#include "mcrl2/atermpp/detail/aterm_list_implementation.h"
 
#endif // MCRL2_ATERMPP_ATERM_LIST_H