queue_popper.hh

#ifndef SUBORDINATION_BASE_QUEUE_POPPER_HH
#define SUBORDINATION_BASE_QUEUE_POPPER_HH

#include <iterator>

#include <subordination/base/container_traits.hh>

namespace sbn {

    template <class Container, class Traits=queue_traits<Container>>
    class queue_pop_iterator:
        public std::iterator<std::input_iterator_tag, typename Container::value_type>{

    private:
        typedef typename Container::value_type cont_value_type;
        typedef std::iterator<std::input_iterator_tag, cont_value_type>
            base_type;

    public:
        using typename base_type::iterator_category;
        using typename base_type::value_type;
        using typename base_type::pointer;
        using typename base_type::reference;
        using typename base_type::difference_type;

    public:
        typedef Container container_type;
        typedef Traits traits_type;

    private:
        container_type* _container = nullptr;

    public:

        inline explicit constexpr
        queue_pop_iterator(container_type& x) noexcept:
        _container(&x) {}

        inline constexpr
        queue_pop_iterator() noexcept = default;

        inline constexpr
        queue_pop_iterator(const queue_pop_iterator& rhs) noexcept = default;

        inline bool
        operator==(const queue_pop_iterator&) const noexcept {
            return this->_container->empty();
        }

        inline bool
        operator!=(const queue_pop_iterator& rhs) const noexcept {
            return !this->operator==(rhs);
        }

        inline const value_type&
        operator*() const noexcept {
            return traits_type::front(*this->_container);
        }

        inline const value_type*
        operator->() const noexcept {
            return &traits_type::front(*this->_container);
        }

        inline queue_pop_iterator&
        operator++() noexcept {
            traits_type::pop(*this->_container);
            return *this;
        }

        inline queue_pop_iterator&
        operator++(int) {
            throw
            std::logic_error("can not post increment sbn::queue_pop_iterator");
            return *this;
        }

    };

    template<class C>
    inline queue_pop_iterator<C>
    queue_popper(C& cont) noexcept {
        return queue_pop_iterator<C>(cont);
    }

    template<class C>
    inline queue_pop_iterator<C>
    queue_popper_end(C&) noexcept {
        return queue_pop_iterator<C>();
    }

    template<class C>
    inline queue_pop_iterator<C,priority_queue_traits<C>>
    priority_queue_popper(C& cont) noexcept {
        return queue_pop_iterator<C,priority_queue_traits<C>>(cont);
    }

    template<class C>
    inline queue_pop_iterator<C,priority_queue_traits<C>>
    priority_queue_popper_end(C&) noexcept {
        return queue_pop_iterator<C,priority_queue_traits<C>>();
    }

    template<class C>
    inline queue_pop_iterator<C,deque_traits<C>>
    deque_popper(C& cont) noexcept {
        return queue_pop_iterator<C,deque_traits<C>>(cont);
    }

    template<class C>
    inline queue_pop_iterator<C,deque_traits<C>>
    deque_popper_end(C&) noexcept {
        return queue_pop_iterator<C,deque_traits<C>>();
    }

}

#endif // vim:filetype=cpp