stack.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/raw_stack.hpp"
#include "icollection.hpp"
#include "../../size.hpp"
#include "../../string.hpp"

namespace xtd {
  namespace collections {
    namespace generic {
      template<class type_t, class container_t = std::deque<type_t>>
      class stack : public xtd::object, public xtd::collections::generic::icollection<type_t> {
      public:
        
        using value_type = typename icollection<type_t>::value_type;
        using base_type = xtd::collections::generic::helpers::raw_stack<value_type, container_t>;
        using size_type = xtd::size;
        using reference = value_type&;
        using const_reference = const value_type&;
        
        
        stack() = default;
        stack(stack&& stack) {
          data_ = std::move(stack.data_);
          stack.data_ = new_ptr<stack_data>();
        }

        stack(const stack& stack) = default;
        stack(std::stack<type_t>&& stack) {
          auto tmp = std::vector<type_t> {};
          tmp.reserve(stack.size());
          
          while (!stack.empty()) {
            tmp.push_back(std::move(stack.top()));
            stack.pop();
          }
          
          for (auto iterator = tmp.rbegin(); iterator != tmp.rend(); ++iterator)
            data_->items.push(*iterator);
            
          ensure_capacity(count());
        }

        stack(const std::stack<type_t>& stack) {
          struct std_stack : public std::stack<type_t> {
            std_stack(const std::stack<type_t>& stack) : ptr {reinterpret_cast<const std_stack*>(&stack)} {}
            auto begin() const {return ptr->c.begin();}
            auto end() const {return ptr->c.end();}
            const std_stack* ptr;
          };
          auto items = std_stack {stack};
          data_->items = base_type(items.begin(), items.end());
          ensure_capacity(count());
        }

        stack(const ienumerable<value_type>& collection) {
          for (auto item : collection)
            data_->items.push(item);
          ensure_capacity(count());
        }

        stack(size_type capacity) {
          data_->items.reserve(capacity);
        }

        stack(std::initializer_list<type_t> il) {
          data_->items = base_type {il};
          ensure_capacity(count());
        }

        template < std::input_iterator input_iterator_t >
        stack(input_iterator_t first, input_iterator_t last) {
          for (auto iterator = first; iterator != last; ++iterator)
            push(*iterator);
          ensure_capacity(count());
        }

        
        
        auto capacity() const noexcept -> size_type {return data_->items.capacity();}
        [[nodiscard]] auto count() const noexcept -> size_type override {return data_->items.size();}
        
        auto items() const {return std::stack<type_t>(std::deque<type_t>(data_->items.begin(), data_->items.end()));}
        
        
        auto clear() -> void override {
          data_->items.clear();
          ++data_->version;
        }
        
        auto contains(const_reference value) const noexcept -> bool override {
          for (const auto& item : data_->items)
            if (xtd::collections::generic::helpers::equator<type_t> {}(item, value)) return true;
          return false;
        }
        
        auto copy_to(xtd::array<type_t>& array, size_type array_index) const -> void override {
          if (array_index + count() > array.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          array_index += count() - 1;
          for (const auto& item : data_->items)
            array[array_index--] = item;
        }
        
        auto pop() -> value_type {
          auto result = value_type {};
          if (!try_pop(result)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
          return result;
        }
        
        auto push(const_reference value) -> void {
          data_->items.push(value);
          ensure_capacity(count());
          ++data_->version;
        }
        
        auto push(value_type&& value) -> void {
          data_->items.push(std::move(value));
          ensure_capacity(count());
          ++data_->version;
        }
        
        auto ensure_capacity(size_type capacity) -> size_type {
          if (data_->items.capacity() < capacity) data_->items.reserve(capacity);
          return data_->items.capacity();
        }
        
        enumerator<value_type> get_enumerator() const noexcept override {
          struct stack_enumerator : public ienumerator < value_type > {
            explicit stack_enumerator(const stack & items, xtd::size version) : items_(items), version_(version) {}
            
            const value_type& current() const override {
              if (iterator_ == items_.data_->items.crend()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
              if (version_ != items_.data_->version) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
              return *iterator_;
            }
            
            bool move_next() override {
              if (version_ != items_.data_->version) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
              if (index_++ && iterator_ != items_.data_->items.crend()) ++iterator_;
              else iterator_ = items_.data_->items.crbegin();
              return iterator_ != items_.data_->items.crend();
            }
            
            void reset() override {
              index_ = 0;
              version_ = items_.data_->version;
              iterator_ = items_.data_->items.crend();
            }
            
          private:
            size_type index_ = 0;
            const stack& items_;
            typename base_type::const_reverse_iterator iterator_ = items_.data_->items.crend();
            size_type version_ = 0;
          };
          return {new_ptr < stack_enumerator > (self_, data_->version)};
        }
        
        [[nodiscard]] auto peek() const -> value_type {
          auto result = value_type {};
          if (!try_peek(result)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
          return result;
        }
        
        auto to_array() const -> xtd::array<value_type> {
          auto array = xtd::array<value_type>(count());
          copy_to(array, 0);
          return array;
        }
        
        auto to_string() const noexcept -> string override {return xtd::string::format("[{}]", xtd::string::join(", ", self_));}
        
        auto trim_excess() -> void {
          if (count() < static_cast<xtd::size>(capacity() * 0.9)) trim_excess(count());
        }
        
        auto trim_excess(size_type capacity) -> void {
          if (capacity < count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          auto temp = base_type {};
          temp.reserve(capacity);
          for (auto& i : data_->items)
            temp.push(i);
          data_->items = std::move(temp);
          ++data_->version;
        }
        
        [[nodiscard]] auto try_pop(value_type& result) noexcept -> bool {
          if (!try_peek(result)) return false;
          data_->items.pop();
          ++data_->version;
          return true;
        }
        
        [[nodiscard]] auto try_peek(value_type& result) const noexcept -> bool {
          result = count() ? data_->items.top() : type_t {};
          return count();
        }

        
        
        auto operator =(const stack& other) -> stack& = default;
        auto operator =(stack&& other) noexcept -> stack& {
          data_->items = std::move(other.data_->items);
          ++data_->version;
          return self_;
        }

        auto operator =(const std::initializer_list<type_t>& items) -> stack& {
          data_->items = items;
          ++data_->version;
          return self_;
        }
        
        operator std::stack<type_t>() const {return items();}
        
      private:
        auto is_read_only() const noexcept -> bool override {return false;}
        auto is_synchronized() const noexcept -> bool override {return false;}
        const xtd::object& sync_root() const noexcept override {return data_->sync_root;}
        auto add(const type_t& value) -> void override {push(value);}
        auto remove(const type_t&) -> bool override {return false;}
        
        struct stack_data {
          base_type items;
          xtd::object sync_root;
          xtd::size version = 0;
        };
        
        xtd::ptr<stack_data> data_ = xtd::new_ptr<stack_data>();
      };
      
      // Deduction guides for xtd::collections::generic::stack
      // {
      template < class type_t, class container_t>
      stack(stack< type_t, container_t>&&) -> stack<type_t, container_t>;
      
      template < class type_t, class container_t>
      stack(const stack<type_t, container_t>&) -> stack<type_t, container_t>;
      
      template < class type_t>
      stack(const ienumerable<type_t>&) -> stack<type_t>;
      
      template < class type_t>
      stack(std::initializer_list<type_t>) -> stack<type_t>;
      
      template <class input_iterator_t>
      stack(input_iterator_t, input_iterator_t) -> stack<std::iter_value_t<input_iterator_t>>;
      // }
    }
  }
}