callback.h

Go to the documentation of this file.

#pragma once

 
#include <atomic>
#include <memory>
 
#include "symmetri/types.h"
 
namespace symmetri {

template <typename T>
bool isSynchronous(const T &) {
  return false;
}

template <typename T>
void cancel(const T &) {}

template <typename T>
void pause(const T &) {}

template <typename T>
void resume(const T &) {}

template <typename T>
Token fire(const T &callback) {
  if constexpr (std::is_same_v<Token, decltype(callback())>) {
    return callback();
  } else if constexpr (std::is_convertible_v<decltype(callback()), Token>) {
    return Token(callback());
  } else if constexpr (std::is_same_v<void, decltype(callback())>) {
    callback();
    return Success;
  }
}

template <typename T>
Eventlog getLog(const T &) {
  return {};
}
 
template <typename T>
struct identity {
  typedef T type;
};

class Callback {
 public:
  template <typename Transition>
  Callback(Transition callback)
      : self_(std::make_shared<model<Transition>>(std::move(callback))) {}
 
  template <typename T, typename... Args>
  Callback(identity<T>, Args &&...args)
      : self_(std::make_shared<model<T>>(std::forward<Args>(args)...)) {}
 
  Callback(Callback &&f) = default;
  Callback &operator=(Callback &&other) = default;
  Callback(const Callback &o) = delete;
  Callback &operator=(const Callback &other) = delete;
 
  friend Token fire(const Callback &callback) {
    return callback.self_->fire_();
  }
  friend Eventlog getLog(const Callback &callback) {
    return callback.self_->get_log_();
  }
  friend bool isSynchronous(const Callback &callback) {
    return callback.self_->is_synchronous_();
  }
  friend void cancel(const Callback &callback) {
    return callback.self_->cancel_();
  }
  friend void pause(const Callback &callback) {
    return callback.self_->pause_();
  }
  friend void resume(const Callback &callback) {
    return callback.self_->resume_();
  }
  auto getEndTime() const {
    return self_->end_t_.load(std::memory_order_relaxed);
  }
 
 private:
  struct concept_t {
    virtual ~concept_t() = default;
    virtual Token fire_() const = 0;
    virtual Eventlog get_log_() const = 0;
    virtual void cancel_() const = 0;
    virtual void pause_() const = 0;
    virtual void resume_() const = 0;
    virtual bool is_synchronous_() const = 0;
    mutable std::atomic<Clock::time_point> end_t_{Clock::time_point::min()};
  };

  template <typename Transition>
  struct model final : concept_t {
    explicit model(Transition &&t) : transition_(std::move(t)) {}
    template <typename... Args>
    model(Args &&...args) : transition_(std::forward<Args>(args)...) {}
 
    Token fire_() const override {
      auto res = fire(transition_);
      end_t_.store(Clock::now(), std::memory_order_relaxed);
      return res;
    }
    Eventlog get_log_() const override { return getLog(transition_); }
    void cancel_() const override { return cancel(transition_); }
    bool is_synchronous_() const override { return isSynchronous(transition_); }
    void pause_() const override { return pause(transition_); }
    void resume_() const override { return resume(transition_); }
    Transition transition_;
  };
 
  std::shared_ptr<const concept_t> self_;
};
 
}  // namespace symmetri