queue.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/raw_queue.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 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::helpers::raw_queue<value_type, container_t>;
        using size_type = xtd::size;
        using reference = value_type&;
        using const_reference = const value_type&;
        
        
        queue() = default;
        queue(queue&& queue) {
          data_ = std::move(queue.data_);
          queue.data_ = new_ptr<queue_data>();
        }

        queue(const queue& queue) = default;
        queue(std::queue<type_t>&& queue) {
          while (queue.size()) {
            data_->items.push(queue.front());
            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) {
          for (auto item : collection)
            data_->items.push(item);
          ensure_capacity(count());
        }

        queue(size_type capacity) {
          data_->items.reserve(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_->items.capacity();}
        [[nodiscard]] auto count() const noexcept -> size_type override {return data_->items.size();}
        
        auto items() const {return std::queue<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);
          for (const auto& item : data_->items)
            array[array_index++] = item;
        }
        
        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.push(value);
          ensure_capacity(count());
          ++data_->version;
        }
        
        auto enqueue(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 queue_enumerator : public ienumerator < value_type > {
            explicit queue_enumerator(const queue & items, xtd::size version) : items_(items), version_(version) {}
            
            const value_type& current() const override {
              if (iterator_ == items_.data_->items.cend()) 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.cend()) ++iterator_;
              else iterator_ = items_.data_->items.cbegin();
              return iterator_ != items_.data_->items.cend();
            }
            
            void reset() override {
              index_ = 0;
              version_ = items_.data_->version;
              iterator_ = items_.data_->items.cend();
            }
            
          private:
            size_type index_ = 0;
            const queue& items_;
            typename base_type::const_iterator iterator_ = items_.data_->items.cend();
            size_type version_ = 0;
          };
          return {new_ptr < queue_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_dequeue(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.front() : type_t {};
          return count();
        }

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

        auto operator =(const std::initializer_list<type_t>& items) -> queue& {
          data_->items = items;
          ++data_->version;
          return self_;
        }
        
        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 data_->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::object sync_root;
          xtd::size version = 0;
        };
        
        xtd::ptr<queue_data> data_ = xtd::new_ptr<queue_data>();
      };
      
      // Deduction guides for xtd::collections::generic::queue
      // {
      template < class type_t, class container_t>
      queue(queue< type_t, container_t>&&) -> queue<type_t, container_t>;
      
      template < class type_t, class container_t>
      queue(const queue<type_t, container_t>&) -> queue<type_t, container_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<std::iter_value_t<input_iterator_t>>;
      // }
    }
  }
}