test

fluent++/Continuable.h

@@ -21,7 +21,7 @@
 
 #include "Callback.h"
 
-template <typename _CTy>
+template <typename... _ATy>
 struct Continuable;
 
 template <typename... _ATy>
@@ -39,7 +39,7 @@ public:
         : _callback_insert(std::forward<ForwardFunction>(callback_insert)) { }
 
     template <typename _CTy>
-    Continuable<Callback<_ATy...>>& then(_CTy&& callback)
+    Continuable<Callback<_ATy...>>& then(_CTy&&)
     {
         return *this;
     }
@@ -66,6 +66,14 @@ namespace detail
 
 } // detail
 
+/// Wraps a functional object which expects a r-value callback as argument into a continuable.
+/// The callable is invoked when the continuable shall continue.
+/// For example:
+/// make_continuable([](Callback<int>&& callback)
+/// {
+///     /* Continue here */
+///     callback(5);
+/// });
 template <typename _FTy>
 inline auto make_continuable(_FTy&& functional)
     -> decltype(typename detail::continuable_factory_t<_FTy>::CreateFrom(std::declval<_FTy>()))

fluent++/fluent++.hpp

@@ -8,6 +8,7 @@
 
 #include "functional_unwrap.hpp"
 
+/*
 class fluent_step
 {
     bool released;
@@ -82,6 +83,7 @@ struct ProtoContinueable
         return ProtoContinueable();
     }
 };
+*/
 
 void do_export();
 

test.cpp

@@ -1,6 +1,4 @@
 
-#include "fluent++.hpp"
-
 #include "Callback.h"
 #include "WeakCallbackContainer.h"
 #include "Continuable.h"
@@ -18,45 +16,11 @@ enum SpellCastResult
     SPELL_FAILED_ALREADY_BEING_TAMED = 5
 };
 
-/*
-ProtoContinueable ProtoCastSpell(int id)
+// Continuable<Callback<SpellCastResult>>
+int CastSpell(int id)
 {
-    std::cout << "Cast " << id << std::endl;
-
-    // on success call true
-    return ProtoContinueable();
-}
-
-ProtoContinueable ProtoMoveTo(int point)
-{
-    std::cout << "Move to point " << point << std::endl;
-
-    // on success call true
-    return ProtoContinueable();
-}
-
-void ProtoCastSpell(int id, Callback<SpellCastResult> const& callback)
-{
-    std::cout << "Cast " << id << std::endl;
-
-    // on success call the callback with SPELL_FAILED_SUCCESS
-    callback(SPELL_FAILED_SUCCESS);
-
-    
-void ProtoMoveTo(int point, Callback<bool> const& callback)
-{
-    std::cout << "Move to point " << point << std::endl;
-
-    // on success call true
-    callback(true);
-}
-
-}
-*/
-
-Continuable<Callback<SpellCastResult>> CastSpell(int id)
-{
-    return make_continuable([=](Callback<SpellCastResult>&& callback)
+    return 1;
+    make_continuable([=](Callback<SpellCastResult>&& callback)
     {
         std::cout << "Cast " << id << std::endl;
 
@@ -67,122 +31,16 @@ Continuable<Callback<SpellCastResult>> CastSpell(int id)
 
 int main(int argc, char** argv)
 {
-    /*
-    make_waterfall<Callback<SpellCastResult>>()
-        // .then(std::bind(&CastSpell, 71382, std::placeholders::_1))
-        .then([](SpellCastResult result, Callback<bool> const& callback)
-        {
-            ProtoMoveTo(1, callback);
-        })
-        .then([](bool success)
-        {
-            // Do something final
-            std::cout << "finish everything" << std::endl;
-        });
-
-    
-
-    auto cabt = []()
-    {
-        // Do something
-        return ProtoMoveTo(2);
-    };
-
-    typedef Callback<bool> cbd1;
-    typedef WeakCallback<int> cbd2;
-    typedef SharedCallback<std::string> cbd3;
-
-    cbd1 _cbd1;
-    cbd2 _cbd2;
-    cbd3 _cbd3;
-
-    auto _test_make_shared_callback = make_shared_callback([](bool)
-    {
-    
-    });
-
-    Callback<> weak_cb_test;
-
-    {
-        WeakCallbackContainer callback;
-
-        // Some tests
-        ProtoCastSpell(22872)
-            .weak(callback)
-            .then([](bool success)
-            {
-                if (success)
-                {
-                    // do something
-                }
-
-                // Do something
-                return ProtoMoveTo(2);
-            })
-            .then([]
-            {
-                
-
-            });
-
-        std::shared_ptr<int> dealloc_test(new int{2}, [](int* me)
-        {
-            std::cout << "dealloc ok" << std::endl;
-            delete me;
-        });
-
-        auto const cb_void = callback([dealloc_test]
-        {
-            std::cout << "huhu i'm a..." << std::endl;
-
-            auto const cp = dealloc_test;
-        });
-
-        dealloc_test.reset();
-
-        auto const cb_bool = callback([](bool success)
-        {
-            std::cout << "...weak wrapped callback!" << std::endl;
-        });
-
-        weak_cb_test = callback([]
-        {
-            std::cout << "huhu i'm crashsafe (you wont see me)!" << std::endl;
-            std::logic_error("bad logic");
-        });
-
-        cb_void();
-
-        int i = 0;
-        ++i;
-
-        cb_bool(true);
-    }
-
-    // This will never be executed because the CallbackContainer was deallocated and its weak callback proxies are crash safe.
-    weak_cb_test();
-
-    auto weak_2 = make_shared_callback([]
-    {
-        std::cout << "huhu" << std::endl;
-    });
-
-    
-    auto wrapped = make_weak_wrapped_callback(weak_2);
-    auto wrapped2 = make_weak_wrapped_callback(WeakCallback<>(weak_2));
-    wrapped();
-    wrapped2();
-    
-    */
-
     typedef Continuable<Callback<bool>> cont123;
 
     // typedef Continuable<Callback<bool>>::type myty1;
     // typedef Continuable<Callback<bool>, float>::type myty2;
 
     // Continuable<Callback<SpellCastResult>>
-    CastSpell(63362)
-        .then([](SpellCastResult result)
+    CastSpell(63362);
+
+    Continuable<Callback<SpellCastResult>> spell;
+        spell.then([](SpellCastResult result)
         {