slot.h

Go to the documentation of this file.

//
//  signal_set.h
//  slimsig
//
//  Created by Christopher Tarquini on 4/23/14.
//
//
 
#ifndef slimsig_signal_set_h
#define slimsig_signal_set_h
 
#include <vector>
#include <iterator>
#include <algorithm>
#include <type_traits>
 
namespace slimsig {
namespace detail {
 
#if defined(_MSC_VER)
#define _FORCE_INLINE __forceinline
#else
#define _FORCE_INLINE [[gnu::always_inline]] inline
#endif
 
template <class T>
_FORCE_INLINE T default_value() { return T(); }
template<> _FORCE_INLINE void default_value<void>() {};
};
 
 
template <class Callback, class SlotID>
class basic_slot;
 
template <class R, class... Args, class SlotID>
class basic_slot<R(Args...), SlotID> {
public:
  using callback = std::function<R(Args...)>;
  using slot_id = SlotID;
  
  basic_slot(slot_id sid, callback fn) : m_fn(std::move(fn)), m_slot_id(sid), m_is_connected(bool(m_fn)), m_is_running(false) {};
  basic_slot() : basic_slot(0, nullptr) {};
  template <class... Arguments>
  basic_slot(slot_id sid, Arguments&&... args) : m_fn(std::forward<Arguments>(args)...), m_slot_id(sid), m_is_connected(bool(m_fn)), m_is_running(false) {};
  basic_slot(basic_slot&&) = default;
  basic_slot(const basic_slot&) = default;
  inline basic_slot& operator=(const basic_slot&) = default;
  inline basic_slot& operator=(basic_slot&&) = default;
  
  _FORCE_INLINE
  bool operator==(const basic_slot& other) const{
    return m_slot_id == other.m_slot_id;
  }
  _FORCE_INLINE
  bool operator==(const slot_id& other) const {
    return m_slot_id == other;
  }
  _FORCE_INLINE
  bool operator <(const basic_slot& other) const {
    return m_slot_id < other.m_slot_id;
  }
  _FORCE_INLINE
  bool operator <(const slot_id& other) const {
    return m_slot_id < other;
  }
  _FORCE_INLINE
  bool operator >(const basic_slot& other) const {
    return m_slot_id > other.m_slot_id;
  }
  _FORCE_INLINE
  bool operator >(const slot_id& other) const {
    return m_slot_id > other;
  }
  _FORCE_INLINE
  bool operator <=(const slot_id& other) const {
    return m_slot_id <= other;
  }
  _FORCE_INLINE
  bool operator >=(const slot_id& other) const {
    return m_slot_id >= other;
  }
  _FORCE_INLINE
  explicit operator bool()  const{
   return m_is_connected;
  }
  _FORCE_INLINE
  bool connected() const {
    return m_is_connected;
  }
  _FORCE_INLINE
  void disconnect() {
    m_is_connected = false;
    if (!m_is_running) {
      m_fn = nullptr;
    }
  }
  
  [[deprecated("Use operator()")]] _FORCE_INLINE
  const callback& operator*() const{
    return m_fn;
  };
  [[deprecated( "Use operator()" )]] _FORCE_INLINE
  const callback* operator->() const {
    return &m_fn;
  }
  _FORCE_INLINE
  R operator() (Args... args) const{
    struct invoke_guard
    {
      const basic_slot& slot;
      ~invoke_guard() { slot.m_is_running = false;}
    } guard { *this };
    m_is_running = true;
    return m_fn(std::forward<Args>(args)...);
  }
  callback m_fn;
  slot_id m_slot_id;
  bool m_is_connected;
  mutable bool m_is_running;
};
 
template < class T,
           class IDGenerator = std::size_t,
           class FlagType = bool,
           class Allocator = std::allocator<std::function<T>>
         >
class slot_list : public std::enable_shared_from_this<slot_list<T, IDGenerator, FlagType, Allocator>>{
  using id_generator = IDGenerator;
  using flag = FlagType;
  static auto slot_id_helper(IDGenerator gen) -> decltype(gen++);
public:
  using slot_id = decltype(slot_id_helper(std::declval<IDGenerator>()));
  using slot = basic_slot<T, slot_id>;
  using callback = typename slot::callback;
  using allocator_type = typename std::allocator_traits<Allocator>::template rebind_traits<slot>::allocator_type;
  using container_type = std::vector<slot, allocator_type>;
  using value_type = typename container_type::value_type;
  using reference = typename container_type::reference;
  using const_reference = typename container_type::const_reference;
  using size_type = typename container_type::size_type;
  using pointer = typename container_type::pointer;
  using iterator = typename container_type::iterator;
  using const_iterator = typename container_type::const_iterator;
 
  slot_list() : active(), pending(), last_id(1), is_locked(false)  {};
  slot_list(allocator_type alloc) : active{alloc}, pending{std::move(alloc)}, last_id(1), is_locked(false) {};
  slot_list(slot_list&&) = default;
  slot_list(const slot_list&) = default;
  
  bool try_lock() { lock(); return true; }
  void lock() { is_locked = true; }
  
  
  void unlock() {
    using std::make_move_iterator;
    using std::sort;
    
    struct guard_t{
      flag& locked;
      container_type& pending;
      ~guard_t() { locked = false; pending.clear();};
    } guard { is_locked, pending };
    // sort offset in case of error
    auto offset = active_size() - !active_empty();
    try {
      active.insert(active.end(), make_move_iterator(pending.begin()), make_move_iterator(pending.end()));
    } catch (...) {
      // make sure we are still sorted properly
      sort(active.begin() + offset, active.end());
      throw;
    }
  }
  
  bool locked() const noexcept (noexcept(bool(std::declval<FlagType>()))) { return is_locked; }
  
  slot_id push(const value_type& value) {
    using std::move;
    auto& queue = !is_locked ? active : pending;
    auto sid = last_id++;
    queue.emplace_back({ sid, move(value)});
    return sid;
  }
  
  slot_id push(value_type&& value) {
    using std::move;
    auto& queue = !is_locked ? active : pending;
    auto sid = last_id++;
    queue.emplace_back({ sid, move(value)});
    return sid;
  }
  
  template <class... Args>
  slot_id emplace(Args&&... args) {
    auto& queue = !is_locked ? active : pending;
    auto sid = last_id++;
    queue.emplace_back(sid, std::forward<Args>(args)...);
    return sid;
  }
  
  template <class U, class... Args>
  slot_id emplace_extended(Args&&... args) {
    auto& queue = !is_locked ? active : pending;
    auto sid = last_id++;
    queue.emplace_back(sid, U{std::forward<Args>(args)..., {this->shared_from_this(), sid}});
    return sid;
  }
  
  
  
  inline iterator erase(const_iterator position) { return active.erase(position); }
  inline iterator erase(const_iterator begin, const_iterator end) { return active.erase(begin, end); }
  
  inline iterator begin() { return active.begin(); }
  inline iterator end() { return active.end(); }
  inline const_iterator cbegin() const { return active.cbegin(); }
  inline const_iterator cend() const { return active.cend(); }
  inline size_type active_size() const { return active.size(); }
  inline reference back() { return active.back(); }
  inline const_reference cback() const { return active.cback(); }
  inline size_type pending_size() const { return pending_size(); }
  inline size_type total_size() const { return active.size() + pending.size(); }
  inline void clear() { active.clear(); pending.clear(); }
  inline bool active_empty() const { return active_size() == 0; }
  inline bool pending_empty() const { return pending_size() == 0; }
  inline bool empty() const { return total_size() == 0; }
  
  iterator find(slot_id index) noexcept {
    auto end = active.end();
    auto slot = find(index, active.begin(), end);
    if (slot == end) {
      auto pend = pending.end();
      slot = find(index, pending.begin(), pend);
      if (slot == pend) slot = end;
    }
    return slot;
  };
  
  const_iterator find(slot_id index) const noexcept{
    auto end = active.cend();
    auto slot = find(index, active.cbegin(), end);
    if (slot == end) {
      auto pend = pending.cend();
      slot = find(index, pending.cbegin(), pend);
      if (slot == pend) slot = end;
    }
    return slot;
  };
private:
  // for internal use only
  template <class Iterator>
  static Iterator find(slot_id index, Iterator begin, Iterator end) noexcept{
    using std::distance;
    using std::lower_bound;
    using std::find_if;
    using std::bind;
    using std::less_equal;
    
    begin = find_if(lower_bound(begin, end, index), end, [&] (const_reference slot){
      return index >= index;
    });
    return begin != end && *begin == index ? begin : end;
  };
  container_type active;
  container_type pending;
  id_generator last_id;
  flag is_locked;
};
 
}
 
 
#endif