Method loadSubstitutionRuleFromJSON

src/bt_factory.cpp:520–571

}

void BehaviorTreeFactory::loadSubstitutionRuleFromJSON(const std::string& json_text)
{
  auto const json = nlohmann::json::parse(json_text);

  std::unordered_map<std::string, TestNodeConfig> configs;

  // TestNodeConfigs is optional: users may only have string-based
  // substitution rules that map to already-registered node types.
  if(json.contains("TestNodeConfigs"))
  {
    auto test_configs = json.at("TestNodeConfigs");
    for(auto const& [name, test_config] : test_configs.items())
    {
      auto& config = configs[name];

      auto return_status = test_config.at("return_status").get<std::string>();
      config.return_status = convertFromString<NodeStatus>(return_status);
      if(test_config.contains("async_delay"))
      {
        config.async_delay =
            std::chrono::milliseconds(test_config["async_delay"].get<int>());
      }
      if(test_config.contains("post_script"))
      {
        config.post_script = test_config["post_script"].get<std::string>();
      }
      if(test_config.contains("success_script"))
      {
        config.success_script = test_config["success_script"].get<std::string>();
      }
      if(test_config.contains("failure_script"))
      {
        config.failure_script = test_config["failure_script"].get<std::string>();
      }
    }
  }

  auto substitutions = json.at("SubstitutionRules");
  for(auto const& [node_name, test] : substitutions.items())
  {
    auto test_name = test.get<std::string>();
    auto it = configs.find(test_name);
    if(it == configs.end())
    {
      addSubstitutionRule(node_name, test_name);
    }
    else
    {
      addSubstitutionRule(node_name, it->second);
    }
  }
}

const std::unordered_map<std::string, BehaviorTreeFactory::SubstitutionRule>&
BehaviorTreeFactory::substitutionRules() const