Merge pull request #3 from NikitkoCent/remake

Remake

Author: Nikita Provotorov

CMakeLists.txt

@@ -52,20 +52,15 @@ if (CMAKE_VERSION VERSION_LESS 2.8.11)
 endif()
 # ================================ GOOGLETEST END =======================================
 
-add_executable(unittesting include/traits.h
-                           include/stream.h
-                           include/stream_traits.h
-                           include/filters_lib.h
-                           include/filter.h
-                           include/is_filters_factory_for.h
-                           include/detail/stream_impl.h
-                           include/detail/traits_impl.h
+add_executable(unittesting include/stream.h
+                           include/traits.h
+                           include/value_holder.h
+                           include/continuation.h
+                           include/operations.h
                            include/detail/stream_base.h
-                           include/detail/utility.h
-                           include/detail/stream_traits_impl.h
-                           include/detail/stream_filter_impl.h
-                           include/detail/filter_impl.h
-                           include/detail/is_filters_factory_for_impl.h
+                           include/detail/traits_impl.h
+                           include/detail/stream_impl.h
+                           include/detail/continuation_impl.h
                            tests/stream_deduction_guides.cpp
                            tests/filters_int_finite_stream.cpp
                            tests/filters_int_infinite_stream.cpp

include/continuation.h

@@ -0,0 +1,15 @@
+#ifndef CPP_STREAM_CONTINUATION_H
+#define CPP_STREAM_CONTINUATION_H
+
+#include "detail/continuation_impl.h"
+
+namespace stream
+{
+    template<bool MakesFinite, typename F>
+    detail::Continuation<F, MakesFinite> makeContinuation(F &&f)
+    {
+        return {::std::forward<F>(f)};
+    }
+}
+
+#endif //CPP_STREAM_CONTINUATION_H

include/detail/continuation_impl.h

@@ -0,0 +1,40 @@
+#ifndef CPP_STREAM_DETAIL_CONTINUATION_IMPL_H
+#define CPP_STREAM_DETAIL_CONTINUATION_IMPL_H
+
+#include <type_traits>  // ::std::decay_t
+#include <utility>      // ::std::move, ::std::forward
+
+namespace stream
+{
+    namespace detail
+    {
+        template<typename C, bool ManagesFiniteness>
+        class Continuation
+        {
+        public:
+            template<typename F>
+            Continuation(F &&continuation)
+                : continuation(::std::forward<F>(continuation))
+            {}
+
+            template<typename V, typename S, bool Fin = ManagesFiniteness,
+                     ::std::enable_if_t<Fin>* = nullptr>
+            decltype(auto) operator()(V &&value, const S& stream, bool &end)
+            {
+                return continuation(::std::forward<V>(value), stream, end);
+            }
+
+            template<typename V, typename S, bool Fin = ManagesFiniteness,
+                     ::std::enable_if_t<!Fin>* = nullptr>
+            decltype(auto) operator()(V &&value, const S& stream)
+            {
+                return continuation(::std::forward<V>(value), stream);
+            }
+
+        private:
+            ::std::decay_t<C> continuation;
+        };
+    }
+}
+
+#endif //CPP_STREAM_DETAIL_CONTINUATION_IMPL_H

include/detail/filter_impl.h

@@ -1,62 +1,61 @@
 #ifndef CPP_STREAM_DETAIL_STREAM_BASE_H
 #define CPP_STREAM_DETAIL_STREAM_BASE_H
 
-#include "traits_impl.h"                    // InvokeResultT
-#include "stream_traits_impl.h"             // IsStreamFilterFor
-#include "is_filters_factory_for_impl.h"    // IsFiltersFactoryFor
-#include <type_traits>                      // ::std::enable_if_t, ::std::decay_t, ::std::is_reference
-#include <utility>                          // ::std::move, ::std::forward
+#include "traits_impl.h"
+#include <type_traits>  // ::std::enable_if_t
+#include <optional>     // ::std::optional
+#include "../value_holder.h"
 
 namespace stream
 {
     template<typename, typename>
     struct Stream;
 
+
     namespace detail
     {
-        template<typename, typename, typename>
-        class StreamFilter;
+        template<typename OldStream, typename Contin>
+        struct CombinedStreamTag;
 
 
-        template<typename T, bool Finiteness, typename StreamImpl>
-        class StreamBase
+        template<typename T, bool Finiteness, typename Derived>
+        struct StreamBase
         {
-        public:
-            using Type = ::std::conditional_t<::std::is_reference<T>::value,
-                                              ::std::reference_wrapper<::std::remove_reference_t<T>>,
-                                              T>;
+            using ValueType = RemoveCVRefT<T>;
             static constexpr bool IsFinite = Finiteness;
 
 
-            template<typename Filter, typename ::std::enable_if_t<IsStreamFilterFor<Filter, StreamImpl>::value>* = nullptr>
-            auto operator|(Filter &&filter)
+            bool isEnd() const
             {
-                using V = typename InvokeResultT<::std::decay_t<Filter>, Type&&, const StreamImpl&, bool&>::value_type;
-                return stream::Stream<V, StreamFilter<StreamImpl, Filter, void>>(::std::move(static_cast<StreamImpl&>(*this)),
-                                                                                 ::std::forward<Filter>(filter));
+                static_assert(IsFinite, "This Stream is infinite");
+                return static_cast<const Derived*>(this)->isEndImpl();
             }
 
 
-            template<typename Factory, typename ::std::enable_if_t<!IsStreamFilterFor<Factory, StreamImpl>::value
-                                                                   && IsFiltersFactoryFor<Factory, StreamImpl>::value>* = nullptr>
-            auto operator|(Factory &&factory)
+            template<typename Contin, ::std::enable_if_t<IsContinuationForV<Contin, Derived>>* = nullptr>
+            auto operator|(Contin &&contin)
             {
-                return operator|(::std::forward<Factory>(factory).template createFilter<StreamImpl>());
-            };
+                using V = UnwrapValueHolderT<typename ContinuationForTraits<Contin, Derived>::ValueType>;
+                using RetStreamT = stream::Stream<V, CombinedStreamTag<Derived, ::std::remove_reference_t<Contin>>>;
 
+                return RetStreamT(::std::move(static_cast<Derived&>(*this)), ::std::forward<Contin>(contin));
+            }
 
-            template<typename Term, typename ::std::enable_if_t<!IsStreamFilterFor<Term, StreamImpl>::value
-                                                                && !IsFiltersFactoryFor<Term, StreamImpl>::value>* = nullptr>
-            decltype(auto) operator|(Term &&nonFilter)
+
+            template<typename Factory, ::std::enable_if_t<!IsContinuationForV<Factory, Derived>
+                                                          && IsContinuationsFactoryForV<Factory, Derived>>* = nullptr>
+            auto operator|(Factory &&factory)
             {
-                return ::std::forward<Term>(nonFilter)(::std::move(static_cast<StreamImpl&>(*this)));
+                return operator|(::std::forward<Factory>(factory).template createContinuation<Derived>());
             }
 
 
-            bool isEnd() const
+            template<typename Consumer, ::std::enable_if_t< !IsContinuationForV<Consumer, Derived>
+                                                            && !IsContinuationsFactoryForV<Consumer, Derived>
+                                                            && IsConsumerForV<Consumer, Derived> >* = nullptr>
+            decltype(auto) operator|(Consumer &&consumer)
             {
-                static_assert(IsFinite, "This stream is infinite");
-                return static_cast<const StreamImpl *>(this)->isEndImpl();
+                return ::std::forward<Consumer>(consumer)(::std::move(static_cast<Derived&>(*this)));
             }
         };
     }