feat(util,flow): 1.11.7, 给Action添加vars()变量功能

Author: hevakelcj

modules/base/defines.h

@@ -43,8 +43,31 @@
     class_name(class_name &&) = delete; \
     class_name& operator = (class_name &&) = delete
 
+#define DECLARE_COPY_FUNC(class_name) \
+    class_name(const class_name& other); \
+    class_name& operator = (const class_name& other)
+
+#define DECLARE_MOVE_RESET_FUNC(class_name) \
+    class_name(class_name&& other); \
+    class_name& operator = (class_name&& other); \
+    void reset()
+
+//! 基于copy()，实现复构造与赋值函数
+#define IMPL_COPY_FUNC(class_name) \
+    class_name::class_name(const class_name& other) \
+    { \
+        copy(other); \
+    } \
+    class_name& class_name::operator = (const class_name& other) \
+    { \
+        if (this != &other) { \
+            copy(other); \
+        } \
+        return *this; \
+    }
+
 //! 基于无参构造、析构、swap，实现reset与移动函数
-#define IMP_MOVE_RESET_FUNC_BASE_ON_SWAP(class_name) \
+#define IMPL_MOVE_RESET_FUNC(class_name) \
     class_name::class_name(class_name&& other) \
     { \
         swap(other); \

modules/flow/action.cpp

@@ -56,6 +56,8 @@ void Action::toJson(Json &js) const {
     js["label"] = label_;
   js["state"] = ToString(state_);
   js["result"] = ToString(result_);
+
+  vars_.toJson(js["vars"]);
 }
 
 bool Action::start() {
@@ -324,6 +326,10 @@ void Action::cancelDispatchedCallback() {
   }
 }
 
+void Action::setParent(Action *parent) {
+  vars_.setParent(&(parent->vars_));
+}
+
 Action::Reason::Reason(const Reason &other)
   : code(other.code)
   , message(other.message)

modules/flow/action.h

@@ -28,6 +28,7 @@
 #include <tbox/base/defines.h>
 #include <tbox/base/json_fwd.h>
 #include <tbox/event/loop.h>
+#include <tbox/util/variables.h>
 
 #include "action_reason.h"
 
@@ -123,6 +124,10 @@ class Action {
     bool stop();    //!< 停止
     void reset();   //!< 重置，将所有的状态恢复到刚构建状态
 
+    void setParent(Action *parent);
+
+    util::Variables& vars() { return vars_; }
+
   protected:
     //! 主动暂停动作
     bool block(const Reason &why = Reason(),    //!< 阻塞原因
@@ -169,6 +174,8 @@ class Action {
     bool is_base_func_invoked_ = false; //! 是否已调用基类函数
     //! 检查使用者在重写的 onStart(),onPause(),onResume(),onStop(),onFinished() 中是否调用了基类的函数
     //! 如果没有调用，则打警告提示
+
+    util::Variables vars_;
 };
 
 //! 枚举转字串

modules/flow/actions/composite_action.cpp

@@ -39,6 +39,7 @@ bool CompositeAction::setChild(Action *child) {
     child_ = child;
     child_->setFinishCallback(std::bind(&CompositeAction::onChildFinished, this, _1, _2, _3));
     child_->setBlockCallback(std::bind(&CompositeAction::onChildBlocked, this, _1, _2));
+    child_->setParent(this);
 
     return true;
 }

modules/flow/actions/function_action.cpp

@@ -42,6 +42,20 @@ FunctionAction::FunctionAction(event::Loop &loop, FuncWithReason &&func)
     TBOX_ASSERT(func_with_reason_ != nullptr);
 }
 
+FunctionAction::FunctionAction(event::Loop &loop, FuncWithVars &&func)
+  : Action(loop, "Function")
+  , func_with_vars_(std::move(func))
+{
+    TBOX_ASSERT(func_with_vars_ != nullptr);
+}
+
+FunctionAction::FunctionAction(event::Loop &loop, FuncWithReasonVars &&func)
+  : Action(loop, "Function")
+  , func_with_reason_vars_(std::move(func))
+{
+    TBOX_ASSERT(func_with_reason_vars_ != nullptr);
+}
+
 void FunctionAction::onStart() {
     Action::onStart();
 
@@ -53,6 +67,12 @@ void FunctionAction::onStart() {
     } else if (func_with_reason_) {
       finish(func_with_reason_(reason), reason);
 
+    } else if (func_with_vars_) {
+      finish(func_with_vars_(vars()), reason);
+
+    } else if (func_with_reason_vars_) {
+      finish(func_with_reason_vars_(reason, vars()), reason);
+
     } else {
       TBOX_ASSERT(isReady());
     }

modules/flow/actions/function_action.h

@@ -29,22 +29,35 @@ class FunctionAction : public Action {
   public:
     using Func = std::function<bool()>;
     using FuncWithReason = std::function<bool(Reason &)>;
+    using FuncWithVars = std::function<bool(util::Variables &)>;
+    using FuncWithReasonVars = std::function<bool(Reason &, util::Variables &)>;
 
     explicit FunctionAction(event::Loop &loop);
     explicit FunctionAction(event::Loop &loop, Func &&func);
     explicit FunctionAction(event::Loop &loop, FuncWithReason &&func);
+    explicit FunctionAction(event::Loop &loop, FuncWithVars &&func);
+    explicit FunctionAction(event::Loop &loop, FuncWithReasonVars &&func);
 
-    virtual bool isReady() const { return bool(func_) || bool(func_with_reason_); }
+    virtual bool isReady() const {
+        return bool(func_) ||
+               bool(func_with_reason_) ||
+               bool(func_with_vars_) ||
+               bool(func_with_reason_vars_);
+    }
 
     inline void setFunc(Func &&func) { func_ = std::move(func); }
     inline void setFunc(FuncWithReason &&func) { func_with_reason_ = std::move(func); }
+    inline void setFunc(FuncWithVars &&func) { func_with_vars_ = std::move(func); }
+    inline void setFunc(FuncWithReasonVars &&func) { func_with_reason_vars_ = std::move(func); }
 
   protected:
     virtual void onStart() override;
 
   private:
     Func func_;
+    FuncWithVars   func_with_vars_;
     FuncWithReason func_with_reason_;
+    FuncWithReasonVars   func_with_reason_vars_;
 };
 
 }

modules/flow/actions/function_action_test.cpp

@@ -18,10 +18,12 @@
  * of the source tree.
  */
 #include <gtest/gtest.h>
+#include <tbox/base/json.hpp>
 #include <tbox/event/loop.h>
 #include <tbox/base/scope_exit.hpp>
 
 #include "function_action.h"
+#include "sequence_action.h"
 
 namespace tbox {
 namespace flow {
@@ -105,5 +107,62 @@ TEST(FunctionAction, WithReason) {
     EXPECT_TRUE(is_callback);
 }
 
+TEST(FunctionAction, WithVars) {
+    auto loop = event::Loop::New();
+    SetScopeExitAction([loop] { delete loop; });
+
+    SequenceAction seq(*loop, SequenceAction::Mode::kAnyFail);
+
+    seq.vars().define("r1", false);
+    seq.vars().define("r2", 0);
+
+    auto func1 = new FunctionAction(*loop,
+      [] (util::Variables &v) {
+        v.set("r1", true);
+        return true;
+      }
+    );
+    auto func2 = new FunctionAction(*loop,
+      [] (Action::Reason &r, util::Variables &v) {
+        r.code = 1001;
+        r.message = "test";
+        v.set("r2", 200);
+        return true;
+      }
+    );
+
+    seq.addChild(func1);
+    seq.addChild(func2);
+
+    bool is_callback = false;
+    seq.setFinishCallback(
+        [&] (bool is_succ, const Action::Reason &r, const Action::Trace &) {
+            is_callback = true;
+            EXPECT_EQ(r.code, 1001);
+            EXPECT_EQ(r.message, "test");
+            loop->exitLoop();
+        }
+    );
+
+    EXPECT_TRUE(seq.isReady());
+    seq.start();
+
+    loop->runLoop();
+    EXPECT_TRUE(is_callback);
+
+    {
+        Json js;
+        EXPECT_TRUE(seq.vars().get("r1", js));
+        EXPECT_TRUE(js.is_boolean());
+        EXPECT_TRUE(js.get<bool>());
+    }
+    {
+        Json js;
+        EXPECT_TRUE(seq.vars().get("r2", js));
+        EXPECT_TRUE(js.is_number());
+        EXPECT_EQ(js.get<int>(), 200);
+    }
+}
+
 }
 }

modules/flow/actions/if_else_action.cpp

@@ -55,6 +55,7 @@ bool IfElseAction::setChildAs(Action *child, const std::string &role) {
         if (if_action_ != nullptr) {
             if_action_->setFinishCallback(std::bind(&IfElseAction::onCondActionFinished, this, _1, _2, _3));
             if_action_->setBlockCallback(std::bind(&IfElseAction::block, this, _1, _2));
+            if_action_->setParent(this);
         }
         return true;
 
@@ -64,6 +65,7 @@ bool IfElseAction::setChildAs(Action *child, const std::string &role) {
         if (succ_action_ != nullptr) {
             succ_action_->setFinishCallback(std::bind(&IfElseAction::finish, this, _1, _2, _3));
             succ_action_->setBlockCallback(std::bind(&IfElseAction::block, this, _1, _2));
+            succ_action_->setParent(this);
         }
         return true;
 
@@ -73,6 +75,7 @@ bool IfElseAction::setChildAs(Action *child, const std::string &role) {
         if (fail_action_ != nullptr) {
             fail_action_->setFinishCallback(std::bind(&IfElseAction::finish, this, _1, _2, _3));
             fail_action_->setBlockCallback(std::bind(&IfElseAction::block, this, _1, _2));
+            fail_action_->setParent(this);
         }
         return true;
     }

modules/flow/actions/loop_action.cpp

@@ -39,6 +39,7 @@ LoopAction::LoopAction(event::Loop &loop, Action *child, Mode mode)
     TBOX_ASSERT(child_ != nullptr);
     child_->setFinishCallback(std::bind(&LoopAction::onChildFinished, this, _1, _2, _3));
     child_->setBlockCallback(std::bind(&LoopAction::block, this, _1, _2));
+    child_->setParent(this);
 }
 
 LoopAction::~LoopAction() {
@@ -56,6 +57,7 @@ bool LoopAction::setChild(Action *child) {
     if (child_ != nullptr) {
         child_->setFinishCallback(std::bind(&LoopAction::onChildFinished, this, _1, _2, _3));
         child_->setBlockCallback(std::bind(&LoopAction::block, this, _1, _2));
+        child_->setParent(this);
     }
     return true;
 }

modules/flow/actions/loop_if_action.cpp

@@ -50,6 +50,7 @@ bool LoopIfAction::setChildAs(Action *child, const std::string &role) {
         if (if_action_ != nullptr) {
             if_action_->setFinishCallback(std::bind(&LoopIfAction::onIfFinished, this, _1, _2, _3));
             if_action_->setBlockCallback(std::bind(&LoopIfAction::block, this, _1, _2));
+            if_action_->setParent(this);
         }
         return true;
 
@@ -59,6 +60,7 @@ bool LoopIfAction::setChildAs(Action *child, const std::string &role) {
         if (exec_action_ != nullptr) {
             exec_action_->setFinishCallback(std::bind(&LoopIfAction::onExecFinished, this, _2, _3));
             exec_action_->setBlockCallback(std::bind(&LoopIfAction::block, this, _1, _2));
+            exec_action_->setParent(this);
         }
         return true;
     }