stack.h

Go to the documentation of this file.

// Author(s): Jan Friso Groote, 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_STANDARD_CONTAINER_STACK_H
#define MCRL2_ATERMPP_STANDARD_CONTAINER_STACK_H
 
#include "mcrl2/atermpp/detail/aterm_container.h"
#include "mcrl2/atermpp/detail/thread_aterm_pool.h"
#include "mcrl2/atermpp/standard_containers/deque.h"
#include "mcrl2/utilities/shared_mutex.h"
 
namespace atermpp
{
 
template < class T, 
           class Container = atermpp::deque< T > > 
class stack
{
private:
  Container m_container;
 
public:
  
  typedef typename Container::allocator_type allocator_type;
  typedef typename Container::value_type value_type;
  typedef typename Container::size_type size_type;
  typedef typename Container::reference reference;
  typedef typename Container::const_reference const_reference;
  typedef typename Container::iterator iterator;
  typedef typename Container::const_iterator const_iterator;
  
  explicit stack(const Container& cont = Container())
   : m_container(cont)     
  {}
 
  explicit stack( Container&& cont )
   : m_container(cont)
  {}
 
  stack(const stack& other) = default;
  stack(stack&& other) = default;
 
  template< class InputIt >
  stack( InputIt first, InputIt last )
    : m_container(first, last)
  {}
 
  template <class InputIterator>
  stack(InputIterator first, InputIterator last,
        const allocator_type& alloc = allocator_type())
   : m_container(first, last, alloc)  
  {}
 
  template< class Alloc >
  explicit stack( const Alloc& alloc )
    : m_container(alloc)
  {}
 
  template< class Alloc >
  stack( const Container& cont, const Alloc& alloc )
    : m_container(cont, alloc)
  {}
 
  template< class Alloc >
  stack( Container&& cont, const Alloc& alloc )
    : m_container(cont, alloc)
  {}
 
  template< class Alloc >
  stack( const stack& other, const Alloc& alloc)
    : m_container(other.m_container, alloc)
  {}
 
  template< class Alloc >
  stack( stack&& other, const Alloc& alloc)
    : m_container(std::move(other.m_container), alloc)
  {}
 
  template< class InputIt, class Alloc >
  stack( InputIt first, InputIt last, const Alloc& alloc )
    : m_container(first, last, alloc)
  {}
    
  stack& operator=(const stack& other) = default;
 
  stack& operator=(stack&& other) = default;
 
  ~stack()=default;
 
  reference top()
  {
    return m_container.back();
  }
 
  const_reference top() const
  {
    return m_container.back();
  }
 
  bool empty() const
  {
    return m_container.empty();
  }
 
  size_type size() const
  {
    return m_container.size();
  }
 
  void push( const value_type& value )
  {
    m_container.push_back(value);
  }
 
  void push( value_type&& value )
  {
    m_container.push_back(std::move(value));
  }
 
  template< class... Args >
  void emplace( Args&&... args )
  {
    m_container.emplace_back(std::forward<Args>(args)...);
  }
 
  void pop()
  {
    m_container.pop_back();
  }
 
  void swap( stack& other ) noexcept
  {
    using std::swap; swap(m_container, other.m_container);
  }
 
  void mark(std::stack<std::reference_wrapper<detail::_aterm>>& todo) const
  {
    m_container.mark(todo);
  }
};
 
} // namespace atermpp
#endif // MCRL2_ATERMPP_STANDARD_CONTAINER_STACK_H