blackboard.h

Go to the documentation of this file.

#ifndef BLACKBOARD_H
#define BLACKBOARD_H

#include <iostream>
#include <string>
#include <memory>
#include <stdint.h>
#include <unordered_map>
#include <mutex>
#include <sstream>

#include "behaviortree_cpp_v3/basic_types.h"
#include "behaviortree_cpp_v3/utils/safe_any.hpp"
#include "behaviortree_cpp_v3/exceptions.h"

namespace BT
{
class Blackboard
{
public:
  typedef std::shared_ptr<Blackboard> Ptr;

protected:
  // This is intentionally protected. Use Blackboard::create instead
  Blackboard(Blackboard::Ptr parent) : parent_bb_(parent)
  {}

public:
  static Blackboard::Ptr create(Blackboard::Ptr parent = {})
  {
    return std::shared_ptr<Blackboard>(new Blackboard(parent));
  }

  virtual ~Blackboard() = default;

  void enableAutoRemapping(bool remapping);

  const Any* getAny(const std::string& key) const
  {
    std::unique_lock<std::mutex> lock(mutex_);
    auto it = storage_.find(key);

    if(it == storage_.end())
    {
      // Try with autoremapping. This should work recursively
      if(autoremapping_)
      {
        if(auto parent = parent_bb_.lock()) {
          return parent->getAny(key);
        }
      }
      return nullptr;
    }
    return &(it->second->value);
  }

  Any* getAny(const std::string& key)
  {
    // "Avoid Duplication in const and Non-const Member Function,"
    // on p. 23, in Item 3 "Use const whenever possible," in Effective C++, 3d ed
    return const_cast<Any*>(static_cast<const Blackboard&>(*this).getAny(key));
  }

  template <typename T>
  bool get(const std::string& key, T& value) const
  {
    const Any* val = getAny(key);
    if (val)
    {
      value = val->cast<T>();
    }
    return (bool)val;
  }

  template <typename T>
  T get(const std::string& key) const
  {
    const Any* val = getAny(key);
    if (val)
    {
      return val->cast<T>();
    }
    else
    {
      throw RuntimeError("Blackboard::get() error. Missing key [", key, "]");
    }
  }

  template <typename T>
  void set(const std::string& key, const T& value)
  {
    std::unique_lock<std::mutex> lock_entry(entry_mutex_);
    std::unique_lock<std::mutex> lock(mutex_);

    // check local storage
    auto it = storage_.find(key);
    std::shared_ptr<Entry> entry;
    if (it != storage_.end())
    {
      entry = it->second;
    }
    else
    {
      Any new_value(value);
      lock.unlock();
      entry = createEntryImpl(key, PortInfo(PortDirection::INOUT, new_value.type(), {}));
      entry->value = new_value;
      return;
    }

    const PortInfo& port_info = entry->port_info;
    auto& previous_any = entry->value;
    const auto previous_type = port_info.type();

    Any new_value(value);

    if (previous_type && *previous_type != typeid(T) &&
        *previous_type != new_value.type())
    {
      bool mismatching = true;
      if (std::is_constructible<StringView, T>::value)
      {
        Any any_from_string = port_info.parseString(value);
        if (any_from_string.empty() == false)
        {
          mismatching = false;
          new_value = std::move(any_from_string);
        }
      }

      if (mismatching)
      {
        debugMessage();

        throw LogicError("Blackboard::set() failed: once declared, the type of a port "
                         "shall not change. Declared type [",
                         BT::demangle(previous_type), "] != current type [",
                         BT::demangle(typeid(T)), "]");
      }
    }
    previous_any = std::move(new_value);
  }

  const PortInfo* portInfo(const std::string& key);

  void addSubtreeRemapping(StringView internal, StringView external);

  void debugMessage() const;

  std::vector<StringView> getKeys() const;

  void clear()
  {
    std::unique_lock<std::mutex> lock(mutex_);
    storage_.clear();
    internal_to_external_.clear();
  }

  // Lock this mutex before using get() and getAny() and unlock it while you have
  // done using the value.
  std::mutex& entryMutex()
  {
    return entry_mutex_;
  }

  void createEntry(const std::string& key, const PortInfo& info)
  {
    createEntryImpl(key, info);
  }

private:
  struct Entry
  {
    Any value;
    const PortInfo port_info;

    Entry(const PortInfo& info) : port_info(info)
    {}

    Entry(Any&& other_any, const PortInfo& info) :
      value(std::move(other_any)), port_info(info)
    {}
  };

  std::shared_ptr<Entry> createEntryImpl(const std::string& key, const PortInfo& info);

  mutable std::mutex mutex_;
  mutable std::mutex entry_mutex_;
  std::unordered_map<std::string, std::shared_ptr<Entry>> storage_;
  std::weak_ptr<Blackboard> parent_bb_;
  std::unordered_map<std::string, std::string> internal_to_external_;

  bool autoremapping_ = false;
};

}   // namespace BT

#endif   // BLACKBOARD_H