Method insertHook

src/loggers/groot2_publisher.cpp:567–624

}

bool Groot2Publisher::insertHook(std::shared_ptr<Monitor::Hook> hook)
{
  auto const node_uid = hook->node_uid;
  auto it = _p->nodes_by_uid.find(node_uid);
  if(it == _p->nodes_by_uid.end())
  {
    return false;
  }
  const TreeNode::Ptr node = it->second.lock();
  if(!node)
  {
    return false;
  }

  auto injectedCallback = [hook, this](TreeNode& node) -> NodeStatus {
    std::unique_lock<std::mutex> lk(hook->mutex);
    if(!hook->enabled)
    {
      return NodeStatus::SKIPPED;
    }

    // Notify that a breakpoint was reached, using the _p->publisher
    const Monitor::RequestHeader breakpoint_request(Monitor::BREAKPOINT_REACHED);
    zmq::multipart_t request_msg;
    request_msg.addstr(Monitor::SerializeHeader(breakpoint_request));
    request_msg.addstr(std::to_string(hook->node_uid));
    request_msg.send(_p->publisher);

    // wait until someone wake us up
    if(hook->mode == Monitor::Hook::Mode::BREAKPOINT)
    {
      hook->wakeup.wait(lk, [hook]() { return hook->ready || !hook->enabled; });

      hook->ready = false;
      // wait was unblocked but it could be the breakpoint becoming disabled.
      // in this case, just skip
      if(!hook->enabled)
      {
        return NodeStatus::SKIPPED;
      }
    }

    if(hook->remove_when_done)
    {
      // self-destruction at the end of this lambda function
      const std::unique_lock<std::mutex> lk(_p->hooks_map_mutex);
      _p->pre_hooks.erase(hook->node_uid);
      node.setPreTickFunction({});
    }
    return hook->desired_status;
  };

  const std::unique_lock<std::mutex> lk(_p->hooks_map_mutex);
  _p->pre_hooks[node_uid] = hook;
  node->setPreTickFunction(injectedCallback);

  return true;
}