aterm.h

Go to the documentation of this file.

// Author(s): Maurice Laveaux.
// 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_H
#define MCRL2_ATERMPP_DETAIL_ATERM_APPL_H
 
#include "mcrl2/atermpp/aterm_core.h"
#include "mcrl2/utilities/unused.h"
 
#include <array>
 
namespace atermpp
{
 
template <typename Term>
class term_appl_iterator;
 
class aterm;
 
namespace detail
{
 
template<std::size_t N = 1>
class _aterm_appl : public _aterm
{
public:
 
  template<typename ...Terms,
           typename std::enable_if<are_terms<Terms...>::value>::type* = nullptr,
           typename std::enable_if<sizeof...(Terms) == N>::type* = nullptr>
  _aterm_appl(const function_symbol& sym, const Terms& ...arguments)
    : _aterm(sym),
      m_arguments{{arguments...}}
  {
    assert(N == sym.arity()); // The arity of the function symbol matches.
  }
 
  template<typename Iterator,
           typename std::enable_if<mcrl2::utilities::is_iterator<Iterator>::value>::type* = nullptr>
  _aterm_appl(const function_symbol& sym, Iterator it, Iterator end)
    : _aterm(sym)
  {
    // The end is only used for debugging to ensure that the arity and std::distance(it, end) match.
    mcrl2::utilities::mcrl2_unused(end);
 
    for (std::size_t i = 0; i < N; ++i)
    {
      assert(it != end);
      m_arguments[i] = *it;
      ++it;
    }
 
    assert(it == end);
  }
 
  _aterm_appl(const function_symbol& sym, std::array<unprotected_aterm_core, N> arguments)
    : _aterm(sym),
      m_arguments(arguments)
  {
    assert(sym.arity() == N);
  }
 
  template<typename Iterator,
           typename std::enable_if<mcrl2::utilities::is_iterator<Iterator>::value>::type* = nullptr>
  _aterm_appl(const function_symbol& symbol, Iterator it, Iterator end, bool)
    : _aterm(symbol)
  {
    // The end is only used for debugging to ensure that the arity and std::distance(it, end) match.
    mcrl2::utilities::mcrl2_unused(end);
 
    for (std::size_t i = 0; i < symbol.arity(); ++i)
    {
      // Prevent bound checking, the allocator must make sure that symbol.arity() arguments fit.
      assert(it != end);
      m_arguments.data()[i] = *it;
      ++it;
    }
 
    assert(it == end);
  }
 
  const aterm_core& arg(std::size_t index) const
  {
    return static_cast<const aterm_core&>(m_arguments.data()[index]);
  }
 
  explicit operator _aterm_appl<1>& ()
  {
    return reinterpret_cast<_aterm_appl<1>&>(*this);
  }
 
private:
  std::array<unprotected_aterm_core, N> m_arguments; 
};
 
using _term_appl = _aterm_appl<>;
 
template<typename T = _term_appl>
class _aterm_appl_allocator
{
private:
  constexpr static std::size_t term_appl_size(std::size_t arity)
  {
    return sizeof(T) + (arity - 1) * sizeof(aterm_core);
  }
 
public:
  using size_type = std::size_t;
  using pointer = T*;
  using value_type = T;
 
  template <class U>
  struct rebind
  {
    typedef _aterm_appl_allocator<U> other;
  };
 
  template<typename ForwardIterator>
  T* allocate_args(const function_symbol& symbol, ForwardIterator, ForwardIterator)
  {
    // We assume that object T contains the _aterm_appl<aterm, 1> at the end and reserve extra space for parameters.
    char* newTerm = m_packed_allocator.allocate(term_appl_size(symbol.arity()));
    return reinterpret_cast<T*>(newTerm);
  }
 
  T* allocate_args(const function_symbol& symbol, unprotected_aterm_core*)
  {
    // We assume that object T contains the _aterm_appl<aterm, 1> at the end and reserve extra space for parameters.
    char* newTerm = m_packed_allocator.allocate(term_appl_size(symbol.arity()));
    return reinterpret_cast<T*>(newTerm);
  }
 
  template<typename ForwardIterator>
  void construct(T* element, const function_symbol& symbol, ForwardIterator begin, ForwardIterator end)
  {
    new (element) T(symbol, begin, end, true);
  }
 
  void destroy(T* element)
  {
    assert(element != nullptr);
 
    // Only destroy the function symbol.
    _term_appl& term = *element;
    term.function().~function_symbol();
  }
 
  void deallocate(T* element, std::size_t)
  {
    assert(element != nullptr);
 
    // Deallocate the memory of this aterm.
    _term_appl& term = *element;
    m_packed_allocator.deallocate(reinterpret_cast<char*>(element), term_appl_size(term.function().arity()));
  }
 
  // These member functions are to ensure parity with the memory_pool.
  constexpr std::size_t capacity() const { return 0; }
  constexpr std::size_t consolidate() const noexcept { return 0; }
  constexpr bool has_free_slots() const noexcept { return false; }
 
private:
  std::allocator<char> m_packed_allocator;
};
 
static_assert(sizeof(_term_appl) == sizeof(_aterm) + sizeof(aterm_core), "Sanity check: aterm size");
 
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);
 
} // namespace detail
} // namespace atermpp
 
#endif // MCRL2_ATERMPP_DETAIL_ATERM_APPL_H