signalspy.hpp

Go to the documentation of this file.

#pragma once

#ifndef _QI_SIGNALHELPER_HPP_
#define _QI_SIGNALHELPER_HPP_

#include <qi/actor.hpp>
#include <qi/anyobject.hpp>
#include <qi/clock.hpp>
#include <qi/signal.hpp>

namespace qi
{
class SignalSpy: public qi::Actor
{
public:
  template<typename... Args>
  SignalSpy(SignalF<void(Args...)>& signal)
    : _records()
  {
    signal.connect(stranded([this](const Args&... args)
    {
      this->recordCallback(args...);
    }));
  }

  SignalSpy(qi::AnyObject& object, const std::string& signalOrPropertyName)
    : _records()
  {
    object.connect(
          signalOrPropertyName,
          qi::AnyFunction::fromDynamicFunction(
            stranded([this](qi::AnyReferenceVector anything)
    {
      return this->recordAnyCallback(anything);
    })));
  }

  // Non-copyable
  SignalSpy(const SignalSpy&) = delete;
  SignalSpy& operator=(const SignalSpy&) = delete;

  ~SignalSpy()
  {
    joinTasks();
  }

  struct Record
  {
    std::vector<qi::AnyValue> args;

    template<typename T>
    const T& arg(int index) const
    {
      return args[index].asReference().as<T>();
    }
  };

  std::vector<Record> allRecords() const
  {
    return async([this]
    { return _records;
    }).value();
  }

  Record record(size_t index) const
  {
    qiLogDebug("qi.signalspy") << "Getting record #" << index << " "
                               << (strand()->isInThisContext() ? "from strand" : "from outside");

    return async([this, index]
    {
      qiLogDebug("qi.signalspy") << "Getting record #" << index;
      return _records[index];
    }).value();
  }

  Record lastRecord() const
  {
    return async([this]
    {
      assert(!_records.empty()); return _records.back();
    }).value();
  }

  size_t recordCount() const
  {
    qiLogDebug("qi.signalspy") << "Getting record count "
                               << (strand()->isInThisContext() ? "from strand" : "from outside");
    return async([this]
    {
      qiLogDebug("qi.signalspy") << "Getting record count";
      return _records.size();
    }).value();
  }

  QI_API_DEPRECATED_MSG(Use 'recordCount' instead)
  unsigned int getCounter() const
  {
    return async([&]{ return static_cast<unsigned int>(_records.size()); }).value();
  }

  qi::FutureSync<bool> waitUntil(unsigned int nofRecords, const qi::Duration& timeout) const
  {
    qi::Promise<bool> waiting;
    async([this, waiting, nofRecords, timeout]() mutable
    {
      if(nofRecords <= _records.size())
      {
        waiting.setValue(true);
        return;
      }

      qi::SignalLink recordedSubscription;

      // track timeout
      auto timingOut = asyncDelay([this, waiting, &recordedSubscription]() mutable
      {
        waiting.setValue(false);
        recorded.disconnect(recordedSubscription);
      }, timeout);

      // be called after signal emissions are recorded
      recordedSubscription = recorded.connect(stranded(
      [this, waiting, &recordedSubscription, timingOut, nofRecords]() mutable
      {
        if (nofRecords <= _records.size())
        {
          waiting.setValue(true);
          timingOut.cancel();
          recorded.disconnect(recordedSubscription);
        } // no need for scheduling in the strand because it is a direct connection
      })).setCallType(qi::MetaCallType_Direct);
    });
    return waiting.future();
  }

private:
  std::vector<Record> _records;

  mutable qi::Signal<void> recorded;

  template <typename... Args>
  void recordCallback(const Args&... args)
  {
    assert(strand()->isInThisContext());
    _records.emplace_back(Record{{qi::AnyValue::from<Args>(args)...}});
    recorded();
  }

  AnyReference recordAnyCallback(const qi::AnyReferenceVector& args)
  {
    assert(strand()->isInThisContext());
    Record record;
    for (const auto& arg: args)
      record.args.emplace_back(arg.to<qi::AnyValue>());
    _records.emplace_back(std::move(record));
    recorded();
    return AnyReference();
  }
};
}

#endif