aterm_core.h

Go to the documentation of this file.

// Author(s): Jan Friso Groote, Maurice Laveaux, 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_H
#define MCRL2_ATERMPP_ATERM_H
 
#include <algorithm>
#include <assert.h>
#include <sstream>
#include "mcrl2/atermpp/detail/aterm_core.h"
#include "mcrl2/atermpp/type_traits.h"
 
namespace atermpp
{
 
// Forward declaration
namespace detail
{
  class thread_aterm_pool;
}
 
class unprotected_aterm_core
{
  friend detail::_aterm* detail::address(const unprotected_aterm_core& t);
 
protected:
  const detail::_aterm* m_term;
 
public:
 
  unprotected_aterm_core() noexcept
   : m_term(nullptr)
  {}
 
  unprotected_aterm_core(const detail::_aterm* term) noexcept
   : m_term(term)
  {}
 
  bool type_is_appl() const noexcept
  {
    return !type_is_int() && !type_is_list();
  }
 
  bool type_is_int() const noexcept
  {
    const function_symbol& f=m_term->function();
    return f == detail::g_as_int;
  }
 
  bool type_is_list() const noexcept
  {
    const function_symbol& f=m_term->function();
    return f == detail::g_as_list || f == detail::g_as_empty_list;
  }
 
  bool operator ==(const unprotected_aterm_core& t) const
  {
    return m_term == t.m_term;
  }
 
  bool operator !=(const unprotected_aterm_core& t) const
  {
    return m_term!=t.m_term;
  }
 
  bool operator <(const unprotected_aterm_core& t) const
  {
    return m_term<t.m_term;
  }
 
  bool operator >(const unprotected_aterm_core& t) const
  {
    return m_term>t.m_term;
  }
 
  bool operator <=(const unprotected_aterm_core& t) const
  {
    return m_term<=t.m_term;
  }
 
  bool operator >=(const unprotected_aterm_core& t) const
  {
    return m_term>=t.m_term;
  }
 
  bool defined() const
  {
    return m_term != nullptr;
  }
 
  void swap(unprotected_aterm_core& t) noexcept
  {
    std::swap(m_term, t.m_term);
  }
 
  const function_symbol& function() const
  {
    return m_term->function();
  }
};
 
//               
class aterm_core : public unprotected_aterm_core
{
public:
 
  aterm_core() noexcept;
 
  ~aterm_core() noexcept;
 
  explicit aterm_core(const detail::_aterm *t) noexcept;
 
  aterm_core(const aterm_core& other) noexcept;
 
  aterm_core(aterm_core&& other) noexcept;
 
  aterm_core& operator=(const aterm_core& other) noexcept;
 
  //  \detail This can be used as an optimisation, because it avoids getting access to thread local variables,
  //          which is as it stands relatively expensive. The effect is equal to the assignment operator =. 
  aterm_core& assign(const aterm_core& other,
                detail::thread_aterm_pool& pool) noexcept;
 
  template <bool CHECK_BUSY_FLAG=true>
  aterm_core& unprotected_assign(const aterm_core& other) noexcept;
 
  aterm_core& operator=(aterm_core&& other) noexcept;
};
 
namespace detail
{
  inline _aterm* address(const unprotected_aterm_core& t)
  {
    return const_cast<_aterm*>(t.m_term);
  }
}
 
} // namespace atermpp
 
#endif // MCRL2_ATERMPP_ATERM_H