raw_stack.hpp

Go to the documentation of this file.

#pragma once
#include <stack>
#include "../../../self.hpp"

namespace xtd {
  namespace collections {
    namespace generic {
      namespace helpers {
        template<class type_t, class container_t = std::deque<type_t>>
        class raw_stack final : public std::stack<type_t, container_t> {
        public:
          
          using base_type = std::stack<type_t, container_t>; 
          using container_type = typename base_type::container_type; 
          using value_type = typename base_type::value_type; 
          using size_type = typename base_type::size_type; 
          using reference = typename base_type::reference; 
          using const_reference = typename base_type::const_reference; 
          using const_iterator = typename container_type::const_iterator; 
          using const_reverse_iterator = typename container_type::const_reverse_iterator; 
          
          
          raw_stack() {shrink_to_fit();}
          
          explicit raw_stack(size_type capacity) {
            shrink_to_fit();
            ensure_capacity(capacity);
          }
          
          raw_stack(const raw_stack& other) : base_type(other) {shrink_to_fit();}
          
          raw_stack(raw_stack&& other) : base_type(std::move(other)) {shrink_to_fit();}
          
          template<class input_iterator_t>
          raw_stack(input_iterator_t first, input_iterator_t last) : base_type(first, last) {shrink_to_fit();}
          
          template<class allocator_t>
          explicit raw_stack(const allocator_t& alloc) : base_type(alloc) {shrink_to_fit();}
          
          
          auto begin() const -> const_iterator {return base_type::c.cbegin();}
          
          auto capacity() const noexcept -> size_type {return capacity_;}
          
          auto cbegin() const -> const_iterator {return base_type::c.cbegin();}
          
          auto cend() const -> const_iterator {return base_type::c.cend();}
          
          auto crbegin() const -> const_reverse_iterator {return base_type::c.crbegin();}
          
          auto crend() const -> const_reverse_iterator {return base_type::c.crend();}

          auto end() const -> const_iterator {return base_type::c.cend();}
          
          auto items() noexcept -> base_type& {return self_;}
          auto items() const noexcept -> const base_type& {return self_;}
          
          auto rbegin() const -> const_reverse_iterator {return base_type::c.crbegin();}
          
          auto rend() const -> const_reverse_iterator {return base_type::c.crend();}

          auto size() const noexcept -> size_type {return base_type::c.size();}
          
          
          auto clear() -> void {base_type::c.clear();}
          
          auto push(const value_type& value) -> void {
            base_type::push(value);
            ensure_capacity(base_type::c.size());
          }
          
          auto push(value_type&& value) -> void {
            base_type::push(std::move(value));
            ensure_capacity(base_type::c.size());
          }
          
          auto pop() -> void {
            base_type::pop();
            ensure_capacity(size());
          }
          
          auto reserve(size_type count) -> void {
            if (capacity_ >= count) return;
            ensure_capacity(count);
          }
          
          auto shrink_to_fit() -> void {
            base_type::c.shrink_to_fit();
            capacity_ = base_type::c.size();
          }

          
          
          raw_stack& operator=(const raw_stack& other) = default; 
          raw_stack& operator=(raw_stack&& other) = default; 
          operator const base_type& () const noexcept {return self_;} 
          operator base_type& () noexcept {return self_;} 
          
        private:
          auto ensure_capacity(size_type capacity) -> void {
            if (capacity <= capacity_) return;
            capacity_ = capacity;
            auto original_size = base_type::size();
            base_type::c.resize(capacity_);
            base_type::c.resize(original_size); // Restore size while keeping capacity.
          }
          
          size_type capacity_ = base_type::size();
        };
        
        // Deduction guides for xtd::collections::generic::helpers::raw_stack
        // {
        template<class container_t>
        raw_stack(container_t) -> raw_stack<typename container_t::value_type, container_t>;
        
        template<class container_t, class allocator_t>
        raw_stack(container_t, allocator_t) -> raw_stack<typename container_t::value_type, container_t>;
        
        template< class input_iterator_t>
        raw_stack(input_iterator_t, input_iterator_t) -> raw_stack<typename std::iterator_traits<input_iterator_t>::value_type>;
        
        template< class input_iterator_t, class allocator_t>
        raw_stack(input_iterator_t, input_iterator_t, allocator_t) -> raw_stack<typename std::iterator_traits<input_iterator_t>::value_type, std::deque<typename std::iterator_traits<input_iterator_t>::value_type, allocator_t>>;
        // }
      }
    }
  }
}