Merge pull request #4 from NikitkoCent/dev

Release v1.0

Author: Nikita Provotorov

CMakeLists.txt

@@ -52,7 +52,26 @@ if (CMAKE_VERSION VERSION_LESS 2.8.11)
 endif()
 # ================================ GOOGLETEST END =======================================
 
-add_executable(unittesting tests/empty.cpp)
+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/detail/continuation_impl.h
+                           tests/stream_deduction_guides.cpp
+                           tests/filters_int_finite_stream.cpp
+                           tests/filters_int_infinite_stream.cpp
+                           tests/filters_generic_int_stream.cpp
+                           tests/filters_move_only_finite_stream.cpp
+                           tests/filters_move_only_infinite_stream.cpp
+                           tests/filters_generic_move_only_stream.cpp
+                           tests/noisy.h
+                           tests/noisy.cpp
+                           tests/filters_noisy_finite_stream.cpp
+                           tests/filters_generic_noisy_stream.cpp)
 target_link_libraries(unittesting gtest gmock_main Threads::Threads)
 
 add_test(NAME do_unittests COMMAND unittesting)
@@ -72,14 +91,19 @@ endif()
 
 MESSAGE("Build type : ${CMAKE_BUILD_TYPE}")
 MESSAGE("Used compiler : ${CMAKE_CXX_COMPILER}")
-if (CMAKE_BUILD_TYPE EQUAL "Debug")
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     MESSAGE("Compiler flags : ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
-elseif (CMAKE_BUILD_TYPE EQUAL "Release")
+    MESSAGE("Linker flags : ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
+elseif (CMAKE_BUILD_TYPE STREQUAL "Release")
     MESSAGE("Compiler flags : ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
-elseif (CMAKE_BUILD_TYPE EQUAL "RelWithDebInfo")
+    MESSAGE("Linker flags : ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
+elseif (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
     MESSAGE("Compiler flags : ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
-elseif (CMAKE_BUILD_TYPE EQUAL "MinSizeRel")
+    MESSAGE("Linker flags : ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO}")
+elseif (CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
     MESSAGE("Compiler flags : ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_MINSIZEREL}")
+    MESSAGE("Linker flags : ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL}")
 else()
     MESSAGE("Compiler flags : ${CMAKE_CXX_FLAGS}")
+    MESSAGE("Linker flags : ${CMAKE_EXE_LINKER_FLAGS}")
 endif()

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/stream_base.h

@@ -0,0 +1,64 @@
+#ifndef CPP_STREAM_DETAIL_STREAM_BASE_H
+#define CPP_STREAM_DETAIL_STREAM_BASE_H
+
+#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 OldStream, typename Contin>
+        struct CombinedStreamTag;
+
+
+        template<typename T, bool Finiteness, typename Derived>
+        struct StreamBase
+        {
+            using ValueType = RemoveCVRefT<T>;
+            static constexpr bool IsFinite = Finiteness;
+
+
+            bool isEnd() const
+            {
+                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)));
+            }
+        };
+    }
+}
+
+#endif //CPP_STREAM_DETAIL_STREAM_BASE_H