Stream beta implementation

Author: OnePatchGuy

CMakeLists.txt

@@ -56,6 +56,7 @@ 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/traits_impl.h
                            include/detail/stream_impl.h

include/continuation.h

@@ -5,13 +5,11 @@
 
 namespace stream
 {
-    using detail::Continuation;
-
     template<bool MakesFinite, typename F>
-    Continuation<F, MakesFinite> makeContinuation(F &&f)
+    detail::Continuation<F, MakesFinite> makeContinuation(F &&f)
     {
         return {::std::forward<F>(f)};
-    };
+    }
 }
 
 #endif //CPP_STREAM_CONTINUATION_H

include/detail/stream_base.h

@@ -8,8 +8,16 @@
 
 namespace stream
 {
+    template<typename, typename>
+    struct Stream;
+
+
     namespace detail
     {
+        template<typename OldStream, typename Contin>
+        struct CombinedStreamTag;
+
+
         template<typename T, bool Finiteness, typename Derived>
         struct StreamBase
         {
@@ -22,6 +30,33 @@ namespace stream
                 static_assert(IsFinite, "This Stream is infinite");
                 return static_cast<const Derived*>(this)->isEndImpl();
             }
+
+
+            template<typename Contin, ::std::enable_if_t<IsContinuationForV<Contin, Derived>>* = nullptr>
+            auto operator|(Contin &&contin)
+            {
+                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 Factory, ::std::enable_if_t<!IsContinuationForV<Factory, Derived>
+                                                          && IsContinuationsFactoryForV<Factory, Derived>>* = nullptr>
+            auto operator|(Factory &&factory)
+            {
+                return operator|(::std::forward<Factory>(factory).template createContinuation<Derived>());
+            }
+
+
+            template<typename Consumer, ::std::enable_if_t< !IsContinuationForV<Consumer, Derived>
+                                                            && !IsContinuationsFactoryForV<Consumer, Derived>
+                                                            && IsConsumerForV<Consumer, Derived> >* = nullptr>
+            decltype(auto) operator|(Consumer &&consumer)
+            {
+                return ::std::forward<Consumer>(consumer)(::std::move(static_cast<Derived&>(*this)));
+            }
         };
     }
 }

include/detail/stream_impl.h

@@ -204,14 +204,18 @@ namespace stream
 
 
         // Combined
+        template<typename OldStream, typename Contin>
+        struct CombinedStreamTag;
+
         template<typename OldStream, typename F, bool ManagesFiniteness>
-        struct CombinedStreamTag {};
+        struct CombinedStreamTag<OldStream, Continuation<F, ManagesFiniteness>>
+        {};
 
         #define CS_PARENT StreamBase<T, StreamTraits<OldStream>::IsFinite | ManagesFiniteness, Derived>
 
         template<typename T, typename F, bool ManagesFiniteness, typename Derived, typename OldStream>
         class StreamImpl<T,
-                         CombinedStreamTag<OldStream, F, ManagesFiniteness>,
+                         CombinedStreamTag<OldStream, Continuation<F, ManagesFiniteness>>,
                          Derived,
                          void
                         > : public CS_PARENT

include/detail/traits_impl.h

@@ -243,6 +243,26 @@ namespace stream
         static constexpr bool IsContinuationForV = ContinuationForTraits<C, Stream>::IsContinuation;
         // ============================================================================================================
 
+        // ============================================================================================================
+        template<typename Factory, typename Stream, typename = void>
+        struct ContinuationsFactoryForTraits
+        {
+            static constexpr bool IsFactory = false;
+        };
+
+        template<typename Factory, typename Stream>
+        struct ContinuationsFactoryForTraits<Factory,
+                                             Stream,
+                                             VoidT<::std::enable_if_t<IsContinuationForV<decltype(::std::declval<Factory>().template createContinuation<Stream>()), Stream>>>
+                                            >
+        {
+            static constexpr bool IsFactory = true;
+        };
+
+        template<typename Factory, typename Stream>
+        static constexpr bool IsContinuationsFactoryForV = ContinuationsFactoryForTraits<Factory, Stream>::IsFactory;
+        // ============================================================================================================
+
         // ============================================================================================================
         template<typename T>
         struct UnwrapValueHolder
@@ -253,6 +273,9 @@ namespace stream
         template<typename T>
         struct UnwrapValueHolder<ValueHolder<T>> : UnwrapValueHolder<T>
         {};
+
+        template<typename T>
+        using UnwrapValueHolderT = typename UnwrapValueHolder<T>::Type;
         // ============================================================================================================
     };
 }

include/operations.h

@@ -0,0 +1,15 @@
+#ifndef CPP_STREAM_OPERATIONS_H
+#define CPP_STREAM_OPERATIONS_H
+
+#include "stream.h"
+#include "traits.h"
+
+namespace stream
+{
+    namespace ops
+    {
+
+    }
+}
+
+#endif //CPP_STREAM_OPERATIONS_H