raw_queue.hpp

Go to the documentation of this file.

#pragma once
#include <queue>

namespace xtd {
  namespace collections {
    namespace generic {
      namespace helpers {
        template<class type_t, class container_t = std::deque<type_t>>
        class raw_queue final : public std::queue<type_t, container_t> {
        public:
          
          using base_type = std::queue<type_t, container_t>;
          using container_type = typename base_type::container_type;
          using value_type = typename base_type::value_type;
          using size_type = typename base_type::size_type;
          using reference = typename base_type::reference;
          using const_reference = typename base_type::const_reference;
          using iterator = typename container_type::const_iterator;
          using const_iterator = typename container_type::const_iterator;
          
          
          raw_queue() {shrink_to_fit();}
          explicit raw_queue(size_type capacity) {
            shrink_to_fit();
            ensure_capacity(capacity);
          }
          raw_queue(const raw_queue& other) : base_type(other) {shrink_to_fit();}
          raw_queue(raw_queue&& other) : base_type(std::move(other)) {shrink_to_fit();}
          template<class input_iterator_t>
          raw_queue(input_iterator_t first, input_iterator_t last) : base_type(first, last) {shrink_to_fit();}
          template<class allocator_t>
          explicit raw_queue(const allocator_t& alloc) : base_type(alloc) {shrink_to_fit();}
          template<class allocator_t>
          raw_queue(const container_t& cont, const allocator_t& alloc) : base_type(cont, alloc) {shrink_to_fit();}
          template<class allocator_t>
          raw_queue(container_t&& cont, const allocator_t& alloc) : base_type(std::move(cont), alloc) {shrink_to_fit();}
          template<class allocator_t >
          raw_queue(const raw_queue& other, const allocator_t& alloc) : base_type(other, alloc) {shrink_to_fit();}
          template<class allocator_t >
          raw_queue(raw_queue&& other, const allocator_t& alloc) : base_type(std::move(other), alloc) {shrink_to_fit();}
          template<class input_iterator_t, class allocator_t >
          raw_queue(input_iterator_t first, input_iterator_t last, const allocator_t& alloc) : base_type(first, last, alloc) {shrink_to_fit();}
          
          
          auto items() const noexcept -> const base_type& {return *this;}
          auto items() noexcept -> base_type& {return *this;}
          
          
          auto begin() const -> const_iterator {return base_type::c.cbegin();}
          
          auto capacity() const noexcept -> size_type {return capacity_;}
          
          auto cbegin() const -> const_iterator {return base_type::c.cbegin();}
          
          auto cend() const -> const_iterator {return base_type::c.cend();}
          
          auto end() const -> const_iterator {return base_type::c.cend();}
          
          auto push(value_type&& value) -> void {
            base_type::push(std::move(value));
            ensure_capacity(base_type::c.size());
          }
          
          auto pop() -> void {base_type::pop();}
          
          auto push(const value_type& value) -> void {
            base_type::push(value);
            ensure_capacity(base_type::c.size());
          }
          
          auto shrink_to_fit() -> void {
            base_type::c.shrink_to_fit();
            ensure_capacity(base_type::c.size());
          }
          
          auto size() const noexcept -> size_type {return base_type::c.size();}
          
          auto reserve(size_type count) -> void {
            if (capacity_ >= count) return;
            ensure_capacity(count);
          }
          
          
          raw_queue& operator =(const raw_queue& other) = default;
          raw_queue& operator =(raw_queue&& other) = default;
          
          operator const base_type& () const noexcept {return *this;}
          operator base_type& () noexcept {return *this;}
          
        private:
          auto ensure_capacity(size_type capacity) -> void {
            if (capacity <= capacity_) return;
            capacity_ = capacity;
            auto original_size = base_type::size();
            base_type::c.resize(capacity_);
            base_type::c.resize(original_size); // Restore the original size and the capacity remains unchanged.
          }
          
          size_type capacity_ = base_type::size();
        };
        
        // Deduction guides for xtd::collections::generic::helpers::raw_queue
        // {
        template<class container_t>
        raw_queue(container_t) -> raw_queue<typename container_t::value_type, container_t>;
        
        template<class container_t, class allocator_t>
        raw_queue(container_t, allocator_t) -> raw_queue<typename container_t::value_type, container_t>;
        
        template< class input_iterator_t>
        raw_queue(input_iterator_t, input_iterator_t) -> raw_queue<typename std::iterator_traits<input_iterator_t>::value_type>;
        
        template< class input_iterator_t, class allocator_t>
        raw_queue(input_iterator_t, input_iterator_t, allocator_t) -> raw_queue<typename std::iterator_traits<input_iterator_t>::value_type, std::deque<typename std::iterator_traits<input_iterator_t>::value_type, allocator_t>>;
        // }
      }
    }
  }
}