concurrent_queue.hpp

Go to the documentation of this file.

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

namespace xtd {
  namespace collections {
    namespace concurrent {
      template<typename type_t>
      class concurrent_queue : 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::queue<value_type>;
        
        
        concurrent_queue() = default;
        concurrent_queue(std::initializer_list<type_t> items) {
          for (const auto& item : items)
            enqueue(item);
        }

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

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

        
        
        [[nodiscard]] auto count() const noexcept -> xtd::usize override {
          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 enqueue(const_reference item) -> void {
          lock_guard_(items_)
          items_.enqueue(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_dequeue(reference result) -> bool {
          lock_guard_(items_)
          return items_.try_dequeue(result);
          return false;
        }
        
        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 {enqueue(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_dequeue(item);}
        
        collection_type items_;
      };
      
      // Deduction guides for xtd::collections::generic::hash_set
      // {
      template<typename type_t>
      concurrent_queue(xtd::collections::generic::ienumerable<type_t>) -> concurrent_queue<type_t>;
      
      template<xtd::iterable iterable_t>
      concurrent_queue(iterable_t&&) -> concurrent_queue<xtd::iterable_value_type<iterable_t>>;
      
      template<typename type_t>
      concurrent_queue(std::initializer_list<type_t>) -> concurrent_queue<type_t>;
      // }
    }
  }
}