aterm.h

Go to the documentation of this file.

// Author(s): 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_APPL_H
#define MCRL2_ATERMPP_ATERM_APPL_H
 
#include "mcrl2/atermpp/aterm_core.h"
#include "mcrl2/atermpp/detail/aterm_appl_iterator.h"
#include "mcrl2/atermpp/detail/aterm_list.h"
#include "mcrl2/atermpp/detail/global_aterm_pool.h"
#include "mcrl2/utilities/type_traits.h"
 
namespace atermpp
{
 
class aterm: public aterm_core
{
protected:
  explicit aterm(detail::_term_appl *t)
   : aterm_core(reinterpret_cast<detail::_aterm*>(t))
  {}
 
public:
  typedef std::size_t size_type;
 
  typedef ptrdiff_t difference_type;
 
  typedef term_appl_iterator<aterm> iterator;
 
  typedef term_appl_iterator<aterm> const_iterator;
 
  aterm():aterm_core()
  {}
 
  /* /// \brief Explicit constructor from an aterm_core.
  explicit aterm(const aterm_core& t) 
   : aterm_core(t)
  {} */
 
  aterm(const aterm& other) noexcept = default;
  aterm& operator=(const aterm& other) noexcept = default;
  aterm(aterm&& other) noexcept = default;
  aterm& operator=(aterm&& other) noexcept = default;
 
  template <class ForwardIterator,
            typename std::enable_if<mcrl2::utilities::is_iterator<ForwardIterator>::value>::type* = nullptr,
            typename std::enable_if<!std::is_same<typename ForwardIterator::iterator_category, std::input_iterator_tag>::value>::type* = nullptr,
            typename std::enable_if<!std::is_same<typename ForwardIterator::iterator_category, std::output_iterator_tag>::value>::type* = nullptr>
  aterm(const function_symbol& sym,
            ForwardIterator begin,
            ForwardIterator end)
  {
    detail::g_thread_term_pool().create_appl_dynamic(*this, sym, begin, end);
    static_assert(!std::is_same<typename ForwardIterator::iterator_category, std::input_iterator_tag>::value,
                  "A forward iterator has more requirements than an input iterator.");
    static_assert(!std::is_same<typename ForwardIterator::iterator_category, std::output_iterator_tag>::value,
                  "A forward iterator has more requirements than an output iterator.");
  }
 
  template <class InputIterator,
            typename std::enable_if<mcrl2::utilities::is_iterator<InputIterator>::value>::type* = nullptr,
            typename std::enable_if<std::is_same<typename InputIterator::iterator_category, std::input_iterator_tag>::value>::type* = nullptr>
  aterm(const function_symbol& sym,
            InputIterator begin,
            InputIterator end)
    : aterm(sym, begin, end, [](const unprotected_aterm_core& term) -> const unprotected_aterm_core& { return term; } )
  {
    static_assert(std::is_same<typename InputIterator::iterator_category, std::input_iterator_tag>::value,
                  "The InputIterator is missing the input iterator tag.");
  }
 
  template <class InputIterator,
            class TermConverter,
            typename std::enable_if<mcrl2::utilities::is_iterator<InputIterator>::value>::type* = nullptr>
  aterm(const function_symbol& sym,
            InputIterator begin,
            InputIterator end,
            TermConverter converter)
  {
    detail::g_thread_term_pool().create_appl_dynamic(*this, sym, converter, begin, end);
    static_assert(!std::is_same<typename InputIterator::iterator_category, std::output_iterator_tag>::value,
                  "The InputIterator has the output iterator tag.");
  }
 
  aterm(const function_symbol& sym)
  {
    detail::g_thread_term_pool().create_term(*this, sym);
  }
 
  template<typename ...Terms>
  aterm(const function_symbol& symbol, const Terms& ...arguments)
  {
    detail::g_thread_term_pool().create_appl(*this, symbol, arguments...);
  }
 
  const function_symbol& function() const
  {
    return m_term->function();
  }
 
  size_type size() const
  {
    return m_term->function().arity();
  }
 
  bool empty() const
  {
    return size()==0;
  }
 
  const_iterator begin() const
  {
    return const_iterator(&static_cast<const aterm&>(reinterpret_cast<const detail::_term_appl*>(m_term)->arg(0)));
  }
 
  const_iterator end() const
  {
    return const_iterator(&static_cast<const aterm&>(reinterpret_cast<const detail::_term_appl*>(m_term)->arg(size())));
  }
 
  constexpr size_type max_size() const
  {
    return std::numeric_limits<size_type>::max();
  }
 
  const aterm& operator[](const size_type i) const
  {
    assert(i < size()); // Check the bounds.
    return static_cast<const aterm&>(reinterpret_cast<const detail::_term_appl*>(m_term)->arg(i));
  }
};
 
typedef void(*term_callback)(const aterm&);
 
extern void add_deletion_hook(const function_symbol&, term_callback);
 
 
template <class Term,
          class ForwardIterator,
          typename std::enable_if<mcrl2::utilities::is_iterator<ForwardIterator>::value>::type* = nullptr,
          typename std::enable_if<!std::is_same<typename ForwardIterator::iterator_category, std::input_iterator_tag>::value>::type* = nullptr,
          typename std::enable_if<!std::is_same<typename ForwardIterator::iterator_category, std::output_iterator_tag>::value>::type* = nullptr>
void make_term_appl(Term& target,
                    const function_symbol& sym,
                    ForwardIterator begin,
                    ForwardIterator end)
{
  detail::g_thread_term_pool().create_appl_dynamic(target, sym, begin, end);
  
  static_assert((std::is_base_of<aterm, Term>::value),"Term must be derived from an aterm");
  static_assert(sizeof(Term)==sizeof(std::size_t),"Term derived from an aterm must not have extra fields");
  static_assert(!std::is_same<typename ForwardIterator::iterator_category, std::input_iterator_tag>::value,
                "A forward iterator has more requirements than an input iterator.");
  static_assert(!std::is_same<typename ForwardIterator::iterator_category, std::output_iterator_tag>::value,
                "A forward iterator has more requirements than an output iterator.");
}
 
 
template <class Term,
          class InputIterator,
          typename std::enable_if<mcrl2::utilities::is_iterator<InputIterator>::value>::type* = nullptr,
          typename std::enable_if<std::is_same<typename InputIterator::iterator_category, std::input_iterator_tag>::value>::type* = nullptr>
void make_term_appl(Term& target,
                    const function_symbol& sym,
                    InputIterator begin,
                    InputIterator end)
{
  make_term_appl(target, sym, begin, end, [](const Term& term) -> const Term& { return term; } );
 
  static_assert((std::is_base_of<aterm, Term>::value),"Term must be derived from an aterm");
  static_assert(sizeof(Term)==sizeof(std::size_t),"Term derived from an aterm must not have extra fields");
  static_assert(std::is_same<typename InputIterator::iterator_category, std::input_iterator_tag>::value,
                "The InputIterator is missing the input iterator tag.");
}
 
template <class Term,
          class InputIterator,
          class TermConverter,
          typename std::enable_if<mcrl2::utilities::is_iterator<InputIterator>::value>::type* = nullptr>
void make_term_appl(Term& target,
                    const function_symbol& sym,
                    InputIterator begin,
                    InputIterator end,
                    TermConverter converter)
{
  detail::g_thread_term_pool().create_appl_dynamic(target, sym, converter, begin, end);
 
  static_assert(std::is_base_of<aterm, Term>::value,"Term must be derived from an aterm");
  static_assert(sizeof(Term)==sizeof(std::size_t),"Term derived from an aterm must not have extra fields");
  static_assert(!std::is_same<typename InputIterator::iterator_category, std::output_iterator_tag>::value,
                "The InputIterator has the output iterator tag.");
}
 
template <class Term>
void make_term_appl(Term& target,
                    const function_symbol& sym)
{
  detail::g_thread_term_pool().create_term(target, sym);
 
  static_assert(std::is_base_of<aterm, Term>::value,"Term must be derived from an aterm");
  static_assert(sizeof(Term)==sizeof(std::size_t),"Term derived from an aterm must not have extra fields");
}
 
template<class Term,
         typename ...Terms>
void make_term_appl(Term& target, const function_symbol& symbol, const Terms& ...arguments)
{
  detail::g_thread_term_pool().create_appl(target, symbol, arguments...);
}
 
template<class Term,
         class INDEX_TYPE,
         typename ...Terms>
void make_term_appl_with_index(aterm& target, const function_symbol& symbol, const Terms& ...arguments)
{
  detail::g_thread_term_pool().create_appl_index<Term, INDEX_TYPE>(target, symbol, arguments...);
}
 
template <class Term1, class Term2>
struct is_convertible : public
    std::conditional<std::is_base_of<aterm, Term1>::value &&
                     std::is_base_of<aterm, Term2>::value && (
                     std::is_convertible<Term1, Term2>::value ||
                     std::is_convertible<Term2, Term1>::value),
                     std::true_type, std::false_type>::type
{ };
 
template <class Derived, class Base>
const Derived& down_cast(const Base& t,
                         typename std::enable_if<is_convertible<Base, Derived>::value &&
                                                 !std::is_base_of<Derived, Base>::value>::type* = nullptr)
{
  static_assert(sizeof(Derived) == sizeof(aterm),
                "aterm cast can only be applied ot types derived from aterms where no extra fields are added");
  assert(Derived(static_cast<const aterm&>(t)) != aterm());
  return reinterpret_cast<const Derived&>(t);
}
 
//         This can be useful when assigning to a term type that contains the derived term type. 
template <class Derived, class Base>
Derived& reference_cast(Base& t,
                        typename std::enable_if<is_convertible<Base, Derived>::value &&
                                                !std::is_base_of<Derived, Base>::value >::type* = nullptr)
{
  static_assert(sizeof(Base) == sizeof(aterm), 
                "aterm cast can only be applied to terms directly derived from aterms");
  static_assert(sizeof(Derived) == sizeof(aterm),
                "aterm cast can only be applied to types derived from aterms where no extra fields are added");
  // We do not check types as the content of the term t is likely to be overwritten shortly. 
  return reinterpret_cast<Derived&>(t);
}
 
//         This can be useful when assigning to a term type that contains the derived term type. 
//         In case Derived and Base are equal, nothing needs to be done. 
template <class Derived>
Derived& reference_cast(Derived& t)
{
  static_assert(sizeof(Derived) == sizeof(aterm), 
                "aterm cast can only be applied to terms directly derived from aterms");
  // We do not check types as the content of the term t is likely to be overwritten shortly. 
  return t;
}
 
template < typename DerivedCont, typename Base, template <typename Elem> class Cont >
const DerivedCont& container_cast(const Cont<Base>& t,
                              typename std::enable_if_t<
                                is_container<DerivedCont, aterm>::value &&
                                std::is_same_v<Cont<typename DerivedCont::value_type>, DerivedCont> &&
                                !std::is_base_of_v<DerivedCont, Cont<Base> > &&
                                is_convertible<Base, typename DerivedCont::value_type>::value
                              >* = nullptr)
{
  static_assert(sizeof(typename DerivedCont::value_type) == sizeof(aterm),
                "aterm cast cannot be applied types derived from aterms where extra fields are added");
  assert(std::all_of(t.begin(),t.end(),[](const Base& u){ return typename DerivedCont::value_type(static_cast<const aterm&>(u)) != aterm();} ));
  return reinterpret_cast<const DerivedCont&>(t);
}
 
template <class Derived, class Base>
const Derived& vertical_cast(const Base& t,
                          typename std::enable_if<is_convertible<Base, Derived>::value>::type* = nullptr)
{
  static_assert(sizeof(Derived) == sizeof(aterm),
                "aterm cast cannot be applied types derived from aterms where extra fields are added");
  assert(Derived(static_cast<const aterm&>(t)) != aterm());
  return reinterpret_cast<const Derived&>(t);
}
 
template < typename DerivedCont, typename Base, template <typename Elem> class Cont >
const DerivedCont& vertical_cast(const Cont<Base>& t,
                              typename std::enable_if_t<
                                is_container<DerivedCont, aterm>::value &&
                                std::is_same_v<Cont<typename DerivedCont::value_type>, DerivedCont> &&
                                is_convertible<Base, typename DerivedCont::value_type>::value
                              >* = nullptr)
{
  static_assert(sizeof(typename DerivedCont::value_type) == sizeof(aterm),
                "aterm cast cannot be applied types derived from aterms where extra fields are added");
  assert(std::all_of(t.begin(),t.end(),[](const Base& u){ return typename DerivedCont::value_type(static_cast<const aterm&>(u)) != aterm();} ));
  return reinterpret_cast<const DerivedCont&>(t);
}
 
/* namespace detail
{
  inline _aterm* address(const unprotected_aterm_core& t)
  {
    return const_cast<_aterm*>(t.m_term);
  }
} */
 
std::ostream& operator<<(std::ostream& out, const atermpp::aterm& t);
 
inline std::string pp(const atermpp::aterm& t)
{
  std::ostringstream oss;
  oss << t;
  return oss.str();
}
 
} // namespace atermpp
 
namespace std
{
 
template <>
inline void swap(atermpp::unprotected_aterm_core& t1, atermpp::unprotected_aterm_core& t2) noexcept
{
  t1.swap(t2);
}
} // namespace std
namespace std
{
 
inline void swap(atermpp::aterm& t1, atermpp::aterm& t2) noexcept
{
  t1.swap(t2);
}
 
template<> struct hash<atermpp::aterm>
{
  std::size_t operator()(const atermpp::aterm& t) const
  {
    return std::hash<atermpp::aterm_core>()(t);
  }
};
 
} // namespace std
 
#endif // MCRL2_ATERMPP_ATERM_APPL_H