concurrent_stack.hpp

Go to the documentation of this file.

#pragma once
#include "iproducer_consumer_collection.hpp"
#include "../generic/stack.hpp"
#include "../../threading/lock_guard.hpp"
#include "../../object.hpp"
#include "../../unused.hpp"

namespace xtd {
  namespace collections {
    namespace concurrent {
      template<typename type_t>
      class concurrent_stack : public xtd::object, public xtd::collections::concurrent::iproducer_consumer_collection<type_t> {
      public:
        
        using value_type = typename iproducer_consumer_collection<type_t>::value_type;
        using reference = value_type&;
        using const_reference = const value_type&;
        using collection_type = xtd::collections::generic::stack<value_type>;
        
        
        concurrent_stack() = default;
        concurrent_stack(std::initializer_list<type_t> items) {
          for (const auto& item : items)
            push(item);
        }

        concurrent_stack(const xtd::collections::generic::ienumerable<value_type>& collection) {
          for (const auto& item : collection)
            push(item);
        }

        template<xtd::iterable iterable_t>
        concurrent_stack(iterable_t&& items) {
          for (const auto& item : items)
            push(item);
        }

        
        
        [[nodiscard]] auto count() const noexcept -> xtd::usize override {
          lock_guard_(items_)
            return items_.count();
          return {};
        }

        [[nodiscard]] auto is_empty() const noexcept -> bool {
          lock_guard_(items_)
            return !items_.count();
          return {};
        }

        [[nodiscard]] auto is_read_only() const noexcept -> bool override {return false;}
        
        [[nodiscard]] auto is_synchronized() const noexcept -> bool override {return true;}
        
        
        auto clear() -> void override {
          lock_guard_(items_)
            items_.clear();
        }
        
        auto copy_to(xtd::array<value_type>& array, xtd::usize array_index) const -> void override {
          lock_guard_(items_)
            items_.copy_to(array, array_index);
        }
        
        virtual auto push(const_reference item) -> void {
          lock_guard_(items_)
            items_.push(item);
        }
        
        template <xtd::iterable iterable_t>
        auto push_range(const iterable_t& items) -> void {
          push_range(items, 0, items.size());
        }

        template <xtd::iterable iterable_t>
        auto push_range(const iterable_t& items, xtd::usize start_index, xtd::usize count) -> void {
          if (start_index + count > items.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          lock_guard_(items_)
            std::for_each(items.begin()+start_index, items.begin()+start_index+count, [this](auto&& item) {items_.push(item);});
        }

        [[nodiscard]] auto get_enumerator() const -> xtd::collections::generic::enumerator<value_type> override {
          static thread_local auto items = xtd::array<value_type> {};
          items = to_array();
          return items.get_enumerator();
        }
        
        [[nodiscard]] auto to_array() const -> xtd::array<value_type> override {
          lock_guard_(items_)
            return items_.to_array();
          return {};
        }
        
        [[nodiscard]] auto to_string() const noexcept -> xtd::string override {
          return to_array().to_string();
        }
        
        virtual auto try_pop(reference result) -> bool {
          lock_guard_(items_)
            return items_.try_pop(result);
          return false;
        }
        
        template <xtd::iterable iterable_t>
        auto try_pop_range(iterable_t& items) -> xtd::usize {
          return try_pop_range(items, 0, items.size());
        }
        
        template <xtd::iterable iterable_t>
        auto try_pop_range(iterable_t& items, xtd::usize start_index, xtd::usize count) -> xtd::usize {
          if (start_index + count > items.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          auto result = xtd::usize {0};
          lock_guard_(items_)
            for (auto index = xtd::usize {0}; index < count; ++index) {
              if (!items_.try_pop(*(items.begin() + start_index + index))) return result;
              ++result;
            }
          return result;
        }
        
        auto try_peek(reference result) const -> bool {
          lock_guard_(items_)
            return items_.try_peek(result);
          return false;
        }

        
      private:
        auto add(const_reference item) -> void override {push(item);}
        [[nodiscard]] auto contains(const_reference item) const noexcept -> bool override {return false;}
        auto remove(const_reference item) -> bool override {return false;}
        [[nodiscard]] auto sync_root() const noexcept -> const object& override {return items_;}
        auto try_add(const_reference item) -> bool override {return false;}
        auto try_take(reference item) -> bool override {return try_pop(item);}
        
        collection_type items_;
      };
      
      // Deduction guides for xtd::collections::concurrent::concurrent_stack
      // {
      template<typename type_t>
      concurrent_stack(xtd::collections::generic::ienumerable<type_t>) -> concurrent_stack<type_t>;
      
      template<xtd::iterable iterable_t>
      concurrent_stack(iterable_t&&) -> concurrent_stack<xtd::iterable_value_type<iterable_t>>;
      
      template<typename type_t>
      concurrent_stack(std::initializer_list<type_t>) -> concurrent_stack<type_t>;
      // }
    }
  }
}