clang form at

Author: facontidavide

examples/broken_sequence.cpp

@@ -6,66 +6,63 @@ using namespace BT;
 
 NodeStatus SayHello()
 {
-    printf("hello\n");
-    return NodeStatus::SUCCESS;
+  printf("hello\n");
+  return NodeStatus::SUCCESS;
 }
 
 class ActionTestNode : public ActionNode
 {
-  public:
-    ActionTestNode(const std::string& name) : ActionNode(name)
+public:
+  ActionTestNode(const std::string& name) : ActionNode(name)
+  {}
+
+  NodeStatus tick() override
+  {
+    time_ = 5;
+    stop_loop_ = false;
+    int i = 0;
+    while (!stop_loop_ && i++ < time_)
     {
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
     }
+    return NodeStatus::SUCCESS;
+  }
 
-    NodeStatus tick() override
-    {
-        time_ = 5;
-        stop_loop_ = false;
-        int i = 0;
-        while (!stop_loop_ && i++ < time_)
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        }
-        return NodeStatus::SUCCESS;
-    }
-
-    virtual void halt() override
-    {
-        stop_loop_ = true;
-        setStatus(NodeStatus::IDLE);
-    }
+  virtual void halt() override
+  {
+    stop_loop_ = true;
+    setStatus(NodeStatus::IDLE);
+  }
 
-  private:
-    int time_;
-    std::atomic_bool stop_loop_;
+private:
+  int time_;
+  std::atomic_bool stop_loop_;
 };
 
 int main()
 {
-    BT::SequenceNode root("root");
-    BT::SimpleActionNode action1("say_hello", std::bind(SayHello));
-    ActionTestNode action2("async_action");
+  BT::SequenceNode root("root");
+  BT::SimpleActionNode action1("say_hello", std::bind(SayHello));
+  ActionTestNode action2("async_action");
 
-    root.addChild(&action1);
-    root.addChild(&action2);
+  root.addChild(&action1);
+  root.addChild(&action2);
 
-    int count = 0;
+  int count = 0;
 
-    NodeStatus status = NodeStatus::RUNNING;
+  NodeStatus status = NodeStatus::RUNNING;
 
-    while (status == NodeStatus::RUNNING)
-    {
-        status = root.executeTick();
+  while (status == NodeStatus::RUNNING)
+  {
+    status = root.executeTick();
 
-        std::cout << count++ << " : " << root.status() << " / " << action1.status() << " / "
-                  << action2.status() << std::endl;
-
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
+    std::cout << count++ << " : " << root.status() << " / " << action1.status() << " / "
+              << action2.status() << std::endl;
 
-    
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
 
-    return 0;
+  return 0;
 }
 // Output
 /*

examples/ex01_wrap_legacy.cpp

@@ -8,42 +8,45 @@
 
 // This is my custom type. We won't know how to read this from a string,
 // unless we implement convertFromString<Point3D>()
-struct Point3D { double x,y,z; };
+struct Point3D
+{
+  double x, y, z;
+};
 
 // We want to create an ActionNode that calls the method MyLegacyMoveTo::go
 class MyLegacyMoveTo
 {
 public:
-    bool go(Point3D goal)
-    {
-        printf("Going to: %f %f %f\n", goal.x, goal.y, goal.z);
-        return true; // true means success in my legacy code
-    }
+  bool go(Point3D goal)
+  {
+    printf("Going to: %f %f %f\n", goal.x, goal.y, goal.z);
+    return true;   // true means success in my legacy code
+  }
 };
 
 // Similarly to the previous tutorials, we need to implement this parsing method,
 // providing a specialization of BT::convertFromString
 namespace BT
 {
-template <> Point3D convertFromString(StringView key)
+template <>
+Point3D convertFromString(StringView key)
 {
-    // three real numbers separated by semicolons
-    auto parts = BT::splitString(key, ';');
-    if (parts.size() != 3)
-    {
-        throw RuntimeError("invalid input)");
-    }
-    else
-    {
-        Point3D output;
-        output.x  = convertFromString<double>(parts[0]);
-        output.y  = convertFromString<double>(parts[1]);
-        output.z  = convertFromString<double>(parts[2]);
-        return output;
-    }
+  // three real numbers separated by semicolons
+  auto parts = BT::splitString(key, ';');
+  if (parts.size() != 3)
+  {
+    throw RuntimeError("invalid input)");
+  }
+  else
+  {
+    Point3D output;
+    output.x = convertFromString<double>(parts[0]);
+    output.y = convertFromString<double>(parts[1]);
+    output.z = convertFromString<double>(parts[2]);
+    return output;
+  }
 }
-} // end anmespace BT
-
+}   // namespace BT
 
 // clang-format off
 static const char* xml_text = R"(
@@ -59,34 +62,33 @@ static const char* xml_text = R"(
 
 int main()
 {
-    using namespace BT;
+  using namespace BT;
 
-    MyLegacyMoveTo move_to;
+  MyLegacyMoveTo move_to;
 
-    // Here we use a lambda that captures the reference of move_to
-    auto MoveToWrapperWithLambda = [&move_to](TreeNode& parent_node) -> NodeStatus
-    {
-        Point3D goal;
-        // thanks to paren_node, you can access easily the input and output ports.
-        parent_node.getInput("goal", goal);
+  // Here we use a lambda that captures the reference of move_to
+  auto MoveToWrapperWithLambda = [&move_to](TreeNode& parent_node) -> NodeStatus {
+    Point3D goal;
+    // thanks to paren_node, you can access easily the input and output ports.
+    parent_node.getInput("goal", goal);
 
-        bool res = move_to.go( goal );
-        // convert bool to NodeStatus
-        return res ? NodeStatus::SUCCESS : NodeStatus::FAILURE;
-    };
+    bool res = move_to.go(goal);
+    // convert bool to NodeStatus
+    return res ? NodeStatus::SUCCESS : NodeStatus::FAILURE;
+  };
 
-    BehaviorTreeFactory factory;
+  BehaviorTreeFactory factory;
 
-    // Register the lambda with BehaviorTreeFactory::registerSimpleAction
+  // Register the lambda with BehaviorTreeFactory::registerSimpleAction
 
-    PortsList ports = { BT::InputPort<Point3D>("goal") };
-    factory.registerSimpleAction("MoveTo", MoveToWrapperWithLambda, ports );
+  PortsList ports = {BT::InputPort<Point3D>("goal")};
+  factory.registerSimpleAction("MoveTo", MoveToWrapperWithLambda, ports);
 
-    auto tree = factory.createTreeFromText(xml_text);
+  auto tree = factory.createTreeFromText(xml_text);
 
-    tree.tickRoot();
+  tree.tickRoot();
 
-    return 0;
+  return 0;
 }
 
 /* Expected output:

examples/ex02_runtime_ports.cpp

@@ -14,58 +14,55 @@ static const char* xml_text = R"(
  )";
 // clang-format on
 
-class ThinkRuntimePort: public BT::SyncActionNode
+class ThinkRuntimePort : public BT::SyncActionNode
 {
-  public:
-  ThinkRuntimePort(const std::string& name,
-               const BT::NodeConfiguration& config)
-    : BT::SyncActionNode(name, config)
-  {
-  }
+public:
+  ThinkRuntimePort(const std::string& name, const BT::NodeConfiguration& config) :
+    BT::SyncActionNode(name, config)
+  {}
 
-  BT::NodeStatus tick() override {
-    setOutput("text", "The answer is 42" );
+  BT::NodeStatus tick() override
+  {
+    setOutput("text", "The answer is 42");
     return NodeStatus::SUCCESS;
   }
 };
 
 class SayRuntimePort : public BT::SyncActionNode
 {
-  public:
-  SayRuntimePort(const std::string& name, const BT::NodeConfiguration& config)
-    : BT::SyncActionNode(name, config)
-  {
-  }
+public:
+  SayRuntimePort(const std::string& name, const BT::NodeConfiguration& config) :
+    BT::SyncActionNode(name, config)
+  {}
 
   // You must override the virtual function tick()
   BT::NodeStatus tick() override
   {
     auto msg = getInput<std::string>("message");
-    if (!msg){
-      throw BT::RuntimeError( "missing required input [message]: ", msg.error() );
+    if (!msg)
+    {
+      throw BT::RuntimeError("missing required input [message]: ", msg.error());
     }
     std::cout << "Robot says: " << msg.value() << std::endl;
     return BT::NodeStatus::SUCCESS;
   }
 };
 
-
 int main()
 {
-    BehaviorTreeFactory factory;
+  BehaviorTreeFactory factory;
 
-    //-------- register ports that might be defined at runtime --------
-    // more verbose way
-    PortsList think_ports = {BT::OutputPort<std::string>("text")};
-    factory.registerBuilder(CreateManifest<ThinkRuntimePort>("ThinkRuntimePort", think_ports),
-                            CreateBuilder<ThinkRuntimePort>());
-    // less verbose way
-    PortsList say_ports = {BT::InputPort<std::string>("message")};
-    factory.registerNodeType<SayRuntimePort>("SayRuntimePort", say_ports);
+  //-------- register ports that might be defined at runtime --------
+  // more verbose way
+  PortsList think_ports = {BT::OutputPort<std::string>("text")};
+  factory.registerBuilder(
+      CreateManifest<ThinkRuntimePort>("ThinkRuntimePort", think_ports),
+      CreateBuilder<ThinkRuntimePort>());
+  // less verbose way
+  PortsList say_ports = {BT::InputPort<std::string>("message")};
+  factory.registerNodeType<SayRuntimePort>("SayRuntimePort", say_ports);
 
-    auto tree = factory.createTreeFromText(xml_text);
-    tree.tickRoot();
-    return 0;
+  auto tree = factory.createTreeFromText(xml_text);
+  tree.tickRoot();
+  return 0;
 }
-
-

examples/ex03_ncurses_manual_selector.cpp

@@ -28,15 +28,13 @@ static const char* xml_text = R"(
 
 int main()
 {
-    BehaviorTreeFactory factory;
-    factory.registerNodeType<DummyNodes::SaySomething>("SaySomething");
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<DummyNodes::SaySomething>("SaySomething");
 
-    auto tree = factory.createTreeFromText(xml_text);
-    auto ret = tree.tickRoot();
+  auto tree = factory.createTreeFromText(xml_text);
+  auto ret = tree.tickRoot();
 
-    std::cout << "Result: " << ret << std::endl;
+  std::cout << "Result: " << ret << std::endl;
 
-    return 0;
+  return 0;
 }
-
-