StlAdapter.h

Go to the documentation of this file.

#pragma once
#include <scl/stream/details/deprecation.h>
#include <iterator>
#include <scl/stream/details/iterator/StreamIterator.h>

namespace scl{
    namespace stream{
        namespace details{
            namespace iterator{
                template <class>
                class StreamIterator;

                template <class T>
                class StlAdapter{
                    public:
                        using iterator_type = StreamIterator<T>;

                        using payload_type = typename iterator_type::payload_type;


                        using iterator_category = std::forward_iterator_tag;

                        using value_type = payload_type;

                        using difference_type = std::ptrdiff_t;

                        using pointer = value_type*;

                        using reference = value_type&;



                    protected:
                        iterator_type* it;

                        payload_type payload;

                    public:
                        explicit StlAdapter(iterator_type* sit = nullptr) : StlAdapter(sit, payload_type::withoutValue()) {
                        }

                        StlAdapter(iterator_type* sit, payload_type payload) : it{sit}, payload{std::move(payload)} {
                            ++(*this); //increment because stream iterators are lazier (start without initial value)
                        }

                        StlAdapter& operator++(){
                            if(it){
                                if(it->hasNext()){
                                    payload = it->next();
                                }else
                                    payload = payload_type::withoutValue();
                            }

                            return *this;
                        }

                        StlAdapter operator++(int){
                            auto ret = *this;
                            ++(*this);
                            return ret;
                        }

                        bool operator==(const StlAdapter& rhs) const{
                            auto&& lhs = *this;

                            /*if(lhs.it != rhs.it)
                                return false;*/

                            return lhs.payload.isInvalid() && rhs.payload.isInvalid();
                        }

                        bool operator !=(const StlAdapter& rhs) const{
                            auto&& lhs = *this;
                            return !(lhs == rhs);
                        }

                        payload_type operator*() const{
                            return payload;
                        }
                };
            }
        }
    }
}