queue_pusher.hh

#ifndef SUBORDINATION_BASE_QUEUE_PUSHER_HH
#define SUBORDINATION_BASE_QUEUE_PUSHER_HH

#include <iterator>

#include <subordination/base/container_traits.hh>

namespace sbn {

    namespace bits {

        typedef std::iterator<std::output_iterator_tag, void, void, void, void>
            queue_push_iterator_base;

    }

    template <class Container, class Traits = queue_traits<Container>>
    class queue_push_iterator: public bits::queue_push_iterator_base {

    private:
        typedef typename Container::value_type cont_value_type;
        typedef bits::queue_push_iterator_base 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;
        typedef cont_value_type object_type;

    private:
        Container& _container;

    public:

        explicit inline
        queue_push_iterator(Container& x) noexcept: _container(x) {}

        inline queue_push_iterator&
        operator=(const object_type& rhs) {
            traits_type::push(this->_container, rhs);
            return *this;
        }

        inline queue_push_iterator&
        operator=(const object_type&& rhs) {
            traits_type::push(this->_container, std::move(rhs));
            return *this;
        }

        inline queue_push_iterator&
        operator*() noexcept {
            return *this;
        }

        inline queue_push_iterator&
        operator++() noexcept {
            return *this;
        }

        inline queue_push_iterator
        operator++(int) noexcept {
            return *this;
        }

    };

    template<class C>
    inline queue_push_iterator<C>
    queue_pusher(C& rhs) {
        return queue_push_iterator<C>(rhs);
    }

    template<class C>
    inline queue_push_iterator<C,priority_queue_traits<C>>
    priority_queue_pusher(C& rhs) {
        return queue_push_iterator<C,priority_queue_traits<C>>(rhs);
    }

    template<class C>
    inline queue_push_iterator<C,deque_traits<C>>
    deque_pusher(C& rhs) {
        return queue_push_iterator<C,deque_traits<C>>(rhs);
    }

}

#endif // vim:filetype=cpp