toVector.h

Go to the documentation of this file.

#pragma once
#include <scl/stream/details/deprecation.h>
#include <vector>
#include <scl/stream/Stream.h>
#include <scl/stream/details/iterator/EndStreamIterator.h>

namespace scl{
    namespace stream{
        namespace terminators {
            namespace pack {
                namespace details {
                    template<class T, class Allocator = std::allocator<T>>
                    class VectorPacker : public stream::details::iterator::EndStreamIterator<std::vector<T, Allocator>, T> {
                        public:
                            using iterator_type = stream::details::iterator::EndStreamIterator<std::vector<T, Allocator>, T>;
                            using value_type = typename iterator_type::value_type;
                            using payload_type = typename iterator_type::payload_type;
                            using result_type = typename iterator_type::result_type;
                            using parent_iterator_type = typename iterator_type::parent_iterator_type;
                            using parent_type = typename iterator_type::parent_type;

                            using allocator_type = Allocator;

                            explicit VectorPacker(parent_type p) : iterator_type{std::move(p)} {
                            }

                            result_type process() {
                                result_type ret = {};

                                /*while (this->hasNext()) {
                                    const auto& alt = this->next().value();
                                    if (alt.hasValue())
                                        ret.push_back(*alt);
                                }*/

                                for(auto&& payload : *this){
                                    if(payload.isValid())
                                        ret.push_back(*payload.value());
                                }

                                return ret;
                            }
                    };

                    struct to_vector_toolbox{};

                    template <class Allocator>
                    struct to_vector_toolbox_alloc{};
                }

                details::to_vector_toolbox toVector(){ return {}; }

                template <class Allocator>
                details::to_vector_toolbox_alloc<Allocator> toVector(){ return {}; }
            }

            template<class T>
            typename pack::details::VectorPacker<T>::result_type operator|(const Stream<T>& lhs, const pack::details::to_vector_toolbox& _) {
                auto packer = pack::details::VectorPacker<T>{lhs.it()};
                return packer.process();
            }

            template<class T, class Allocator>
            typename pack::details::VectorPacker<T, Allocator>::result_type operator|(const Stream<T>& lhs, const pack::details::to_vector_toolbox_alloc<Allocator>& _) {
                auto packer = pack::details::VectorPacker<T, Allocator>{lhs.it()};
                return packer.process();
            }
        }
    }
}