queue.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/raw_queue.hpp"
#include "linked_list.hpp"

namespace xtd {
  namespace collections {
    namespace generic {
      template<class type_t, class allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
      class queue : 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::linked_list<value_type, allocator_t>;
        using size_type = xtd::size;
        using reference = value_type&;
        using const_reference = const value_type&;
        
        
        queue() = default;
        queue(queue&& queue) = default;
        queue(const queue& queue) = default;
        queue(std::queue<type_t>&& queue) {
          while (queue.size())
            data_->items.add(queue.pop());
          ensure_capacity(count());
        }

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

        queue(const ienumerable<value_type>& collection) {
          data_->items = base_type {collection};
          ensure_capacity(count());
        }

        queue(size_type capacity) {
          data_->capacity = capacity;
        }

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

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

        
        
        auto capacity() const noexcept -> size_type {return data_->capacity;}
        [[nodiscard]] auto count() const noexcept -> size_type override {return data_->items.count();}
        
        std::queue<type_t> items() const {return std::queue<type_t>(std::deque<type_t>(data_->items.begin(), data_->items.end()));}
        
        
        auto clear() -> void override {
          data_->items.clear();
        }
        
        auto contains(const_reference value) const noexcept -> bool override {
          return data_->items.contains(value);
        }
        
        auto copy_to(xtd::array<type_t>& array, size_type array_index) const -> void override {
          data_->items.copy_to(array, array_index);
        }
        
        auto dequeue() -> value_type {
          auto result = value_type {};
          if (!try_dequeue(result)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
          return result;
        }
        
        auto enqueue(const_reference value) -> void {
          data_->items.add_last(value);
          ensure_capacity(count());
        }
        
        auto ensure_capacity(size_type capacity) -> size_type {
          if (data_->capacity < capacity) data_->capacity = capacity;
          return data_->capacity;
        }
        
        enumerator<value_type> get_enumerator() const noexcept override {
          return data_->items.get_enumerator();
        }
        
        [[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 data_->items.to_string();}
        
        auto trim_excess() -> void {
          if (count() * 1. < 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);
          data_->capacity = capacity;
        }
        
        [[nodiscard]] auto try_dequeue(value_type& result) noexcept -> bool {
          if (!try_peek(result)) return false;
          data_->items.remove_first();
          return true;
        }
        
        [[nodiscard]] auto try_peek(value_type& result) const noexcept -> bool {
          result = count() ? data_->items.first()->value() : type_t {};
          return count();
        }

        
        
        operator std::queue<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 xtd::as<icollection<value_type>>(data_->items).sync_root();}
        auto add(const type_t& value) -> void override {enqueue(value);}
        auto remove(const type_t&) -> bool override {return false;}
        
        struct queue_data {
          base_type items;
          xtd::size capacity = 0;
        };
        
        xtd::ptr<queue_data> data_ = xtd::new_ptr<queue_data>();
      };
      
      // Deduction guides for xtd::collections::generic::queue
      // {
      template < class type_t, class allocator_t = xtd::collections::generic::helpers::allocator < type_t>>
      queue(queue < type_t, allocator_t >&&) -> queue < type_t, allocator_t >;
      
      template < class type_t, class allocator_t = xtd::collections::generic::helpers::allocator < type_t>>
      queue(const queue < type_t, allocator_t >&) -> queue < type_t, allocator_t >;
      
      template < class type_t>
      queue(const ienumerable < type_t >&) -> queue < type_t >;
      
      template < class type_t>
      queue(std::initializer_list < type_t >) -> queue < type_t >;
      
      template <class input_iterator_t>
      queue(input_iterator_t, input_iterator_t) -> queue<typename input_iterator_t::value_type>;
      // }
    }
  }
}