fix issue #451 and #450. Optional renamed Expected

Author: facontidavide

examples/t03_generic_ports.cpp

@@ -108,7 +108,7 @@ static const char* xml_text = R"(
         <Sequence name="root">
             <CalculateGoal   goal="{GoalPosition}" />
             <PrintTarget     target="{GoalPosition}" />
-            <SetBlackboard   output_key="OtherGoal" value="-1;3" />
+            <Script          code="OtherGoal='-1;3'" />
             <PrintTarget     target="{OtherGoal}" />
         </Sequence>
      </BehaviorTree>

include/behaviortree_cpp/basic_types.h

@@ -11,6 +11,7 @@
 #include <chrono>
 #include <memory>
 #include <string_view>
+#include <variant>
 
 #include "behaviortree_cpp/utils/safe_any.hpp"
 #include "behaviortree_cpp/exceptions.h"
@@ -183,9 +184,9 @@ using enable_if = typename std::enable_if<Predicate::value>::type*;
 template <typename Predicate>
 using enable_if_not = typename std::enable_if<!Predicate::value>::type*;
 
-/** Usage: given a function/method like:
+/** Usage: given a function/method like this:
  *
- *     Optional<double> getAnswer();
+ *     Expected<double> getAnswer();
  *
  * User code can check result and error message like this:
  *
@@ -200,7 +201,11 @@ using enable_if_not = typename std::enable_if<!Predicate::value>::type*;
  *
  * */
 template <typename T>
+#ifdef USE_BTCPP3_OLD_NAMES
 using Optional = nonstd::expected<T, std::string>;
+#else
+using Expected = nonstd::expected<T, std::string>;
+#endif
 // note: we use the name Optional instead of expected because it is more intuitive
 // for users that are not up to date with "modern" C++
 
@@ -220,7 +225,7 @@ using Optional = nonstd::expected<T, std::string>;
  *     }
  *
  * */
-using Result = Optional<void>;
+using Result = Expected<std::monostate>;
 
 bool IsAllowedPortName(StringView str);
 

include/behaviortree_cpp/scripting/operators.hpp

@@ -21,7 +21,7 @@
 #include <utility>
 
 #include "behaviortree_cpp/scripting/any_types.hpp"
-#include "behaviortree_cpp/blackboard.h"
+#include "behaviortree_cpp/scripting/script_parser.hpp"
 
 // Naive implementation of an AST with simple evaluation function.
 namespace BT::Ast
@@ -30,13 +30,6 @@ using SimpleString = SafeAny::SimpleString;
 
 using expr_ptr = std::shared_ptr<struct ExprBase>;
 
-using EnumsTablePtr = std::shared_ptr<std::unordered_map<std::string, int>>;
-
-struct Environment{
-    BT::Blackboard::Ptr vars;
-    EnumsTablePtr enums;
-};
-
 struct ExprBase
 {
     using Ptr = std::shared_ptr<ExprBase>;

include/behaviortree_cpp/scripting/script_parser.hpp

@@ -12,18 +12,39 @@
 
 #pragma once
 
-#include "behaviortree_cpp/scripting/operators.hpp"
+#include "behaviortree_cpp/blackboard.h"
 
 namespace BT
 {
 
-std::string ValidateScript(const std::string& script);
+/// Simple map (string->nt), used to convert enums in the
+/// scripting language
+using EnumsTable = std::unordered_map<std::string, int>;
+using EnumsTablePtr = std::shared_ptr<EnumsTable>;
+
+namespace Ast
+{
+   /**
+   * @brief The Environment class is used to encapsulate
+   * the information and states neded by the sriting language
+   */
+  struct Environment{
+    BT::Blackboard::Ptr vars;
+    EnumsTablePtr enums;
+  };
+}
+
+  /**
+ * @brief ValidateScript will check if a certain string is valid.
+ */
+Result ValidateScript(const std::string& script);
 
 using ScriptFunction = std::function<Any(Ast::Environment& env)>;
 
-Optional<ScriptFunction> ParseScript(const std::string& script);
+Expected<ScriptFunction> ParseScript(const std::string& script);
 
-Optional<Any> ParseScriptAndExecute(Ast::Environment& env, const std::string& script);
+Expected<Any> ParseScriptAndExecute(Ast::Environment& env,
+                                    const std::string& script);
 
 }
 

include/behaviortree_cpp/tree_node.h

@@ -138,9 +138,9 @@ class TreeNode
   using StatusChangeCallback = StatusChangeSignal::CallableFunction;
 
   using PreTickOverrideCallback =
-      std::function<Optional<NodeStatus>(TreeNode&, NodeStatus)>;
+      std::function<Expected<NodeStatus>(TreeNode&, NodeStatus)>;
   using PostTickOverrideCallback =
-      std::function<Optional<NodeStatus>(TreeNode&, NodeStatus, NodeStatus)>;
+      std::function<Expected<NodeStatus>(TreeNode&, NodeStatus, NodeStatus)>;
 
   /**
      * @brief subscribeToStatusChange is used to attach a callback to a status change.
@@ -198,11 +198,11 @@ class TreeNode
      * but using optional.
      */
   template <typename T>
-  Optional<T> getInput(const std::string& key) const
+  Expected<T> getInput(const std::string& key) const
   {
     T out;
     auto res = getInput(key, out);
-    return (res) ? Optional<T>(out) : nonstd::make_unexpected(res.error());
+    return (res) ? Expected<T>(out) : nonstd::make_unexpected(res.error());
   }
 
   template <typename T>
@@ -218,7 +218,7 @@ class TreeNode
 
   static StringView stripBlackboardPointer(StringView str);
 
-  static Optional<StringView> getRemappedKey(StringView port_name,
+  static Expected<StringView> getRemappedKey(StringView port_name,
                                              StringView remapped_port);
 
   /// Notify that the tree should be ticked again()
@@ -304,7 +304,7 @@ class TreeNode
 
   std::shared_ptr<ScriptingEnumsRegistry> scripting_enums_;
 
-  Optional<NodeStatus> checkPreConditions();
+  Expected<NodeStatus> checkPreConditions();
   void checkPostConditions(NodeStatus status);
 
   /// The method used to interrupt the execution of a RUNNING node.

src/script_parser.cpp

@@ -8,9 +8,11 @@
 
 namespace BT
 {
-Optional<ScriptFunction> ParseScript(const std::string& script)
+
+using ErrorReport = lexy_ext::_report_error<char*>;
+
+Expected<ScriptFunction> ParseScript(const std::string& script)
 {
-  using ErrorReport = lexy_ext::_report_error<char*>;
   char error_msgs_buffer[2048];
 
   auto input = lexy::string_input<lexy::utf8_encoding>(script);
@@ -45,7 +47,7 @@ Optional<ScriptFunction> ParseScript(const std::string& script)
   }
 }
 
-BT::Optional<Any> ParseScriptAndExecute(Ast::Environment& env, const std::string& script)
+BT::Expected<Any> ParseScriptAndExecute(Ast::Environment& env, const std::string& script)
 {
   auto executor = ParseScript(script);
   if (executor)
@@ -58,4 +60,31 @@ BT::Optional<Any> ParseScriptAndExecute(Ast::Environment& env, const std::string
   }
 }
 
+Result ValidateScript(const std::string &script)
+{
+  char error_msgs_buffer[2048];
+
+  auto input = lexy::string_input<lexy::utf8_encoding>(script);
+  auto result =
+      lexy::parse<BT::Grammar::stmt>(input, ErrorReport().to(error_msgs_buffer));
+  if (result.has_value() && result.error_count() == 0)
+  {
+    try
+    {
+      std::vector<BT::Ast::ExprBase::Ptr> exprs = LEXY_MOV(result).value();
+      if (exprs.empty())
+      {
+        return nonstd::make_unexpected("Empty Script");
+      }
+      // valid script
+      return {};
+    }
+    catch (std::runtime_error& err)
+    {
+      return nonstd::make_unexpected(err.what());
+    }
+  }
+  return nonstd::make_unexpected(error_msgs_buffer);
+}
+
 }   // namespace BT

src/tree_node.cpp

@@ -98,7 +98,7 @@ void TreeNode::setStatus(NodeStatus new_status)
   }
 }
 
-Optional<NodeStatus> TreeNode::checkPreConditions()
+Expected<NodeStatus> TreeNode::checkPreConditions()
 {
   // check the pre-conditions
   for (size_t index = 0; index < size_t(PreCond::COUNT_); index++)
@@ -269,7 +269,7 @@ StringView TreeNode::stripBlackboardPointer(StringView str)
   return {};
 }
 
-Optional<StringView> TreeNode::getRemappedKey(StringView port_name,
+Expected<StringView> TreeNode::getRemappedKey(StringView port_name,
                                               StringView remapped_port)
 {
   if (remapped_port == "=")