Method set

include/behaviortree_cpp/blackboard.h:272–386

template <typename T>
inline void Blackboard::set(const std::string& key, const T& value)
{
  if(StartWith(key, '@'))
  {
    rootBlackboard()->set(key.substr(1, key.size() - 1), value);
    return;
  }
  std::shared_lock storage_lock(storage_mutex_);

  // check local storage
  auto it = storage_.find(key);
  if(it == storage_.end())
  {
    // create a new entry
    Any new_value(value);
    storage_lock.unlock();
    std::shared_ptr<Blackboard::Entry> entry;
    // if a new generic port is created with a string, it's type should be AnyTypeAllowed
    if constexpr(std::is_same_v<std::string, T>)
    {
      entry = createEntryImpl(key, PortInfo(PortDirection::INOUT));
    }
    else
    {
      PortInfo new_port(PortDirection::INOUT, new_value.type(),
                        GetAnyFromStringFunctor<T>());
      entry = createEntryImpl(key, new_port);
    }

    // Lock entry_mutex before writing to prevent data races with
    // concurrent readers (BUG-1/BUG-8 fix).
    std::scoped_lock entry_lock(entry->entry_mutex);
    entry->value = new_value;
    entry->sequence_id++;
    entry->stamp = std::chrono::steady_clock::now().time_since_epoch();
  }
  else
  {
    // this is not the first time we set this entry, we need to check
    // if the type is the same or not.
    // Copy shared_ptr to prevent use-after-free if another thread
    // calls unset() while we hold the reference (BUG-2 fix).
    auto entry_ptr = it->second;
    storage_lock.unlock();
    Entry& entry = *entry_ptr;

    std::scoped_lock scoped_lock(entry.entry_mutex);

    Any& previous_any = entry.value;
    Any new_value(value);

    // special case: entry exists but it is not strongly typed... yet
    if(!entry.info.isStronglyTyped())
    {
      // Use the new type to create a new entry that is strongly typed.
      entry.info = TypeInfo::Create<T>();
      entry.sequence_id++;
      entry.stamp = std::chrono::steady_clock::now().time_since_epoch();