callback.hh

Go to the documentation of this file.

 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
#pragma once
 
#include <ase/defs.hh>
#include <algorithm>
 
namespace Ase {
 
// == CallbackList<> ==
template<class... A>
class CallbackList : public std::enable_shared_from_this<CallbackList<A...>> {
  CallbackList() {}
public:
  ASE_DEFINE_MAKE_SHARED (CallbackList);
  using Callback = std::function<void(const A&...)>;
  bool    empty   () const              { return funcs_.empty(); }
  bool    del     (size_t id)           { return del_id (id); }
  size_t  add     (const Callback &f)   { return add_id (f); }
  std::function<void()>
  add_delcb (const Callback &f)
  {
    std::shared_ptr<CallbackList> callbacklistp = this->shared_from_this();
    ASE_ASSERT_RETURN (callbacklistp != nullptr, {});
    const size_t id = add_id (f);
    auto destroy_callback = [id, callbacklistp] () { callbacklistp->del (id); };
    return destroy_callback;
  }
  void
  call (const std::function<void(const Callback&, const A&...)> &wrapper, const A &...args)
  {
    size_t next = 0;
    iters_.push_back (&next);
    while (next < funcs_.size())
      // increment next *before* calling callback to be accurate and adjusted by del_id()
      wrapper (funcs_[next++].func, std::forward<const A> (args)...);
    const size_t old_size = iters_.size();
    iters_.erase (std::remove_if (iters_.begin(), iters_.end(),
                                  [&next] (const size_t *p) { return p == &next; }),
                  iters_.end());
    ASE_ASSERT_RETURN (1 == old_size - iters_.size());
  }
  void
  operator() (const A &...args)
  {
    auto caller = [] (const Callback &cb, const A &...args) { cb (std::forward<const A> (args)...); };
    return call (caller, std::forward<const A> (args)...);
  }
private:
  struct Entry { Callback func; size_t id = 0; };
  std::vector<Entry>   funcs_;
  std::vector<size_t*> iters_;
  static size_t
  newid()
  {
    static size_t counter = 0;
    return ++counter;
  }
  size_t
  add_id (const Callback &f)
  {
    const size_t id = newid();
    funcs_.push_back ({ f, id });
    return id;
  }
  bool
  del_id (const size_t id)
  {
    for (size_t j = 0; j < funcs_.size(); j++)
      if (funcs_[j].id == id) {
        funcs_.erase (funcs_.begin() + j);
        for (size_t i = 0; i < iters_.size(); i++)
          if (j < *iters_[i]) // if a callback *before* next
            *iters_[i] -= 1;  // was deleted, adjust next
        return true;
      }
    return false;
  }
  ASE_CLASS_NON_COPYABLE (CallbackList);
};
 
// == RtCall ==
struct RtCall {
  template<typename T> RtCall (T &o, void (T::*f) ());
  template<typename T> RtCall (void (*f) (T*), T *d);
  /*ctor*/             RtCall (void (*f) ());
  explicit             RtCall (const RtCall &call);
  void                 invoke ();
  /*dtor*/            ~RtCall ();
private:
  static constexpr int pdsize = 4;
  ptrdiff_t mem_[pdsize] = { 0, 0, 0, 0 };
  struct Callable {
    virtual void call () const = 0;
  };
  const Callable* callable () const;
};
 
// == JobQueue for cross-thread invocations ==
struct JobQueue {
  using Caller = std::function<void (const std::function<void()>&)>;
  explicit             JobQueue    (const Caller &caller);
  template<typename F> std::invoke_result_t<F>
  inline               operator+=  (const F &job);
private:
  const Caller caller_;
};
 
// == Implementation Details ==
template<typename T>
RtCall::RtCall (T &o, void (T::*f) ())
{
  struct Wrapper : Callable {
    Wrapper (T &o, void (T::*f) ()) : f_ (f), o_ (&o) {}
    void call() const override { return (o_->*f_)(); }
    void (T::*f_) (); T *o_;
  };
  static_assert (sizeof (mem_) >= sizeof (Wrapper));
  Wrapper *w = new (mem_) Wrapper { o, f };
  ASE_ASSERT_RETURN (w == (void*) mem_);
}
 
template<typename T>
RtCall::RtCall (void (*f) (T*), T *d)
{
  struct Wrapper : Callable {
    Wrapper (void (*f) (T*), T *d) : f_ (f), d_ (d) {}
    void call() const override { return f_ (d_); }
    void (*f_) (T*); T *d_;
  };
  static_assert (sizeof (mem_) >= sizeof (Wrapper));
  Wrapper *w = new (mem_) Wrapper { f, d };
  ASE_ASSERT_RETURN (w == (void*) mem_);
}
 
template<typename F> std::invoke_result_t<F>
JobQueue::operator+= (const F &job)
{
  using JobReturnType = std::invoke_result_t<F>;
  static_assert (std::is_same<JobReturnType, void>::value);
  caller_ (job);
}
 
} // Ase