minor changes

Author: facontidavide

include/behaviortree_cpp/controls/try_catch_node.h

@@ -56,14 +56,14 @@ class TryCatchNode : public ControlNode
                              "the node is halted during the try-block") };
   }
 
-  virtual void halt() override;
+  void halt() override;
 
 private:
-  size_t current_child_idx_;
-  size_t skipped_count_;
-  bool in_catch_;
+  size_t current_child_idx_ = 0;
+  size_t skipped_count_ = 0;
+  bool in_catch_ = false;
 
-  virtual BT::NodeStatus tick() override;
+  BT::NodeStatus tick() override;
 };
 
 }  // namespace BT

src/blackboard.cpp

@@ -105,7 +105,7 @@ void Blackboard::debugMessage() const
 {
   // Lock storage_mutex_ (shared) to prevent iterator invalidation from
   // concurrent modifications (BUG-5 fix).
-  const std::shared_lock<std::shared_mutex> storage_lock(storage_mutex_);
+  const std::shared_lock storage_lock(storage_mutex_);
   for(const auto& [key, entry] : storage_)
   {
     auto port_type = entry->info.type();
@@ -141,7 +141,7 @@ std::vector<StringView> Blackboard::getKeys() const
 {
   // Lock storage_mutex_ (shared) to prevent iterator invalidation and
   // dangling StringView from concurrent modifications (BUG-6 fix).
-  const std::shared_lock<std::shared_mutex> storage_lock(storage_mutex_);
+  const std::shared_lock storage_lock(storage_mutex_);
   if(storage_.empty())
   {
     return {};
@@ -157,7 +157,7 @@ std::vector<StringView> Blackboard::getKeys() const
 
 void Blackboard::clear()
 {
-  const std::unique_lock<std::shared_mutex> storage_lock(storage_mutex_);
+  const std::unique_lock storage_lock(storage_mutex_);
   storage_.clear();
 }
 
@@ -198,8 +198,8 @@ void Blackboard::cloneInto(Blackboard& dst) const
 
   // Step 1: snapshot src/dst entries under both storage_mutex_ locks.
   {
-    std::shared_lock<std::shared_mutex> lk1(storage_mutex_, std::defer_lock);
-    std::unique_lock<std::shared_mutex> lk2(dst.storage_mutex_, std::defer_lock);
+    std::shared_lock lk1(storage_mutex_, std::defer_lock);
+    std::unique_lock lk2(dst.storage_mutex_, std::defer_lock);
     std::lock(lk1, lk2);
 
     std::unordered_set<std::string> dst_keys;
@@ -258,10 +258,10 @@ void Blackboard::cloneInto(Blackboard& dst) const
   // Step 3: insert new entries and remove stale ones under dst.storage_mutex_.
   if(!new_entries.empty() || !keys_to_remove.empty())
   {
-    const std::unique_lock<std::shared_mutex> dst_lock(dst.storage_mutex_);
+    const std::unique_lock dst_lock(dst.storage_mutex_);
     for(auto& [key, entry] : new_entries)
     {
-      dst.storage_.insert({ key, std::move(entry) });
+      dst.storage_.try_emplace(key, std::move(entry));
     }
     for(const auto& key : keys_to_remove)
     {
@@ -282,7 +282,7 @@ Blackboard::Ptr Blackboard::parent()
 std::shared_ptr<Blackboard::Entry> Blackboard::createEntryImpl(const std::string& key,
                                                                const TypeInfo& info)
 {
-  const std::unique_lock<std::shared_mutex> storage_lock(storage_mutex_);
+  const std::unique_lock storage_lock(storage_mutex_);
   // This function might be called recursively, when we do remapping, because we move
   // to the top scope to find already existing  entries
 

src/controls/try_catch_node.cpp

@@ -16,9 +16,6 @@ namespace BT
 {
 TryCatchNode::TryCatchNode(const std::string& name, const NodeConfig& config)
   : ControlNode::ControlNode(name, config)
-  , current_child_idx_(0)
-  , skipped_count_(0)
-  , in_catch_(false)
 {
   setRegistrationID("TryCatch");
 }

src/xml_parsing.cpp

@@ -181,13 +181,46 @@ void validateInstanceName(const std::string& name, int line_number)
   }
 }
 
-}  // namespace
-
 struct SubtreeModel
 {
   std::unordered_map<std::string, BT::PortInfo> ports;
 };
 
+void parseSubtreeModelPorts(const XMLElement* sub_node, SubtreeModel& subtree_model)
+{
+  const std::pair<const char*, PortDirection> port_types[3] = {
+    { "input_port", PortDirection::INPUT },
+    { "output_port", PortDirection::OUTPUT },
+    { "inout_port", PortDirection::INOUT }
+  };
+
+  for(const auto& [name, direction] : port_types)
+  {
+    for(auto port_node = sub_node->FirstChildElement(name); port_node != nullptr;
+        port_node = port_node->NextSiblingElement(name))
+    {
+      PortInfo port(direction);
+      auto port_name = port_node->Attribute("name");
+      if(port_name == nullptr)
+      {
+        throw RuntimeError("Missing attribute [name] in port (SubTree model)");
+      }
+      validatePortName(port_name, port_node->GetLineNum());
+      if(auto default_value = port_node->Attribute("default"))
+      {
+        port.setDefaultValue(default_value);
+      }
+      if(auto description = port_node->Attribute("description"))
+      {
+        port.setDescription(description);
+      }
+      subtree_model.ports[port_name] = std::move(port);
+    }
+  }
+}
+
+}  // namespace
+
 struct XMLParser::PImpl
 {
   TreeNode::Ptr createNodeFromXML(const XMLElement* element,
@@ -298,38 +331,7 @@ void BT::XMLParser::PImpl::loadSubtreeModel(const XMLElement* xml_root)
         throw RuntimeError("Missing attribute 'ID' in SubTree element "
                            "within TreeNodesModel");
       }
-      auto& subtree_model = subtree_models[subtree_id];
-
-      const std::pair<const char*, BT::PortDirection> port_types[3] = {
-        { "input_port", BT::PortDirection::INPUT },
-        { "output_port", BT::PortDirection::OUTPUT },
-        { "inout_port", BT::PortDirection::INOUT }
-      };
-
-      for(const auto& [name, direction] : port_types)
-      {
-        for(auto port_node = sub_node->FirstChildElement(name); port_node != nullptr;
-            port_node = port_node->NextSiblingElement(name))
-        {
-          BT::PortInfo port(direction);
-          auto port_name = port_node->Attribute("name");
-          if(port_name == nullptr)
-          {
-            throw RuntimeError("Missing attribute [name] in port (SubTree model)");
-          }
-          // Validate port name
-          validatePortName(port_name, port_node->GetLineNum());
-          if(auto default_value = port_node->Attribute("default"))
-          {
-            port.setDefaultValue(default_value);
-          }
-          if(auto description = port_node->Attribute("description"))
-          {
-            port.setDescription(description);
-          }
-          subtree_model.ports[port_name] = std::move(port);
-        }
-      }
+      parseSubtreeModelPorts(sub_node, subtree_models[subtree_id]);
     }
   }
 }