Class priority_queue_iterator

uspace/lib/cpp/src/__bits/test/adaptors.cpp:44–102

    {
        template<class T, class Comp = std::less<T>>
        class priority_queue_iterator
        {
            public:
                using value_type      = T;
                using reference       = const T&;
                using size_type       = size_t;
                using pointer         = value_type*;
                using difference_type = size_t;

                using iterator_category = forward_iterator_tag;

                priority_queue_iterator(
                    priority_queue<value_type, std::vector<value_type>, Comp> q,
                    bool end = false
                )
                    : queue_{q}, end_{end}
                { /* DUMMY BODY */ }

                priority_queue_iterator(const priority_queue_iterator& other)
                    : queue_{other.queue_}, end_{other.end_}
                { /* DUMMY BODY */ }

                reference operator*()
                {
                    return queue_.top();
                }

                priority_queue_iterator& operator++()
                {
                    queue_.pop();

                    if (queue_.empty())
                        end_ = true;

                    return *this;
                }

                priority_queue_iterator operator++(int)
                {
                    auto old = *this;
                    ++(*this);

                    return old;
                }

                bool operator==(const priority_queue_iterator& rhs) const
                {
                    return end_ == rhs.end_;
                }

                bool operator!=(const priority_queue_iterator& rhs) const
                {
                    return !(*this == rhs);
                }

            private:
                priority_queue<value_type, std::vector<value_type>, Comp> queue_;
                bool end_;