summaryrefslogtreecommitdiff
path: root/lib/bindey/include/nod
diff options
context:
space:
mode:
Diffstat (limited to 'lib/bindey/include/nod')
-rw-r--r--lib/bindey/include/nod/nod.hpp681
1 files changed, 0 insertions, 681 deletions
diff --git a/lib/bindey/include/nod/nod.hpp b/lib/bindey/include/nod/nod.hpp
deleted file mode 100644
index 68e7b8d4..00000000
--- a/lib/bindey/include/nod/nod.hpp
+++ /dev/null
@@ -1,681 +0,0 @@
-#ifndef IG_NOD_INCLUDE_NOD_HPP
-#define IG_NOD_INCLUDE_NOD_HPP
-
-#include <vector> // std::vector
-#include <functional> // std::function
-#include <mutex> // std::mutex, std::lock_guard
-#include <memory> // std::shared_ptr, std::weak_ptr
-#include <algorithm> // std::find_if()
-#include <cassert> // assert()
-#include <thread> // std::this_thread::yield()
-#include <type_traits> // std::is_same
-#include <iterator> // std::back_inserter
-
-namespace nod {
- // implementational details
- namespace detail {
- /// Interface for type erasure when disconnecting slots
- struct disconnector {
- virtual ~disconnector() {}
- virtual void operator()( std::size_t index ) const = 0;
- };
- /// Deleter that doesn't delete
- inline void no_delete(disconnector*){
- };
- } // namespace detail
-
- /// Base template for the signal class
- template <class P, class T>
- class signal_type;
-
-
- /// Connection class.
- ///
- /// This is used to be able to disconnect slots after they have been connected.
- /// Used as return type for the connect method of the signals.
- ///
- /// Connections are default constructible.
- /// Connections are not copy constructible or copy assignable.
- /// Connections are move constructible and move assignable.
- ///
- class connection {
- public:
- /// Default constructor
- connection() :
- _index()
- {}
-
- // Connection are not copy constructible or copy assignable
- connection( connection const& ) = delete;
- connection& operator=( connection const& ) = delete;
-
- /// Move constructor
- /// @param other The instance to move from.
- connection( connection&& other ) :
- _weak_disconnector( std::move(other._weak_disconnector) ),
- _index( other._index )
- {}
-
- /// Move assign operator.
- /// @param other The instance to move from.
- connection& operator=( connection&& other ) {
- _weak_disconnector = std::move( other._weak_disconnector );
- _index = other._index;
- return *this;
- }
-
- /// @returns `true` if the connection is connected to a signal object,
- /// and `false` otherwise.
- bool connected() const {
- return !_weak_disconnector.expired();
- }
-
- /// Disconnect the slot from the connection.
- ///
- /// If the connection represents a slot that is connected to a signal object, calling
- /// this method will disconnect the slot from that object. The result of this operation
- /// is that the slot will stop receiving calls when the signal is invoked.
- void disconnect();
-
- private:
- /// The signal template is a friend of the connection, since it is the
- /// only one allowed to create instances using the meaningful constructor.
- template<class P,class T> friend class signal_type;
-
- /// Create a connection.
- /// @param shared_disconnector Disconnector instance that will be used to disconnect
- /// the connection when the time comes. A weak pointer
- /// to the disconnector will be held within the connection
- /// object.
- /// @param index The slot index of the connection.
- connection( std::shared_ptr<detail::disconnector> const& shared_disconnector, std::size_t index ) :
- _weak_disconnector( shared_disconnector ),
- _index( index )
- {}
-
- /// Weak pointer to the current disconnector functor.
- std::weak_ptr<detail::disconnector> _weak_disconnector;
- /// Slot index of the connected slot.
- std::size_t _index;
- };
-
- /// Scoped connection class.
- ///
- /// This type of connection is automatically disconnected when
- /// the connection object is destructed.
- ///
- class scoped_connection
- {
- public:
- /// Scoped are default constructible
- scoped_connection() = default;
- /// Scoped connections are not copy constructible
- scoped_connection( scoped_connection const& ) = delete;
- /// Scoped connections are not copy assingable
- scoped_connection& operator=( scoped_connection const& ) = delete;
-
- /// Move constructor
- scoped_connection( scoped_connection&& other ) :
- _connection( std::move(other._connection) )
- {}
-
- /// Move assign operator.
- /// @param other The instance to move from.
- scoped_connection& operator=( scoped_connection&& other ) {
- reset( std::move( other._connection ) );
- return *this;
- }
-
- /// Construct a scoped connection from a connection object
- /// @param connection The connection object to manage
- scoped_connection( connection&& c ) :
- _connection( std::forward<connection>(c) )
- {}
-
- /// destructor
- ~scoped_connection() {
- disconnect();
- }
-
- /// Assignment operator moving a new connection into the instance.
- /// @note If the scoped_connection instance already contains a
- /// connection, that connection will be disconnected as if
- /// the scoped_connection was destroyed.
- /// @param c New connection to manage
- scoped_connection& operator=( connection&& c ) {
- reset( std::forward<connection>(c) );
- return *this;
- }
-
- /// Reset the underlying connection to another connection.
- /// @note The connection currently managed by the scoped_connection
- /// instance will be disconnected when resetting.
- /// @param c New connection to manage
- void reset( connection&& c = {} ) {
- disconnect();
- _connection = std::move(c);
- }
-
- /// Release the underlying connection, without disconnecting it.
- /// @returns The newly released connection instance is returned.
- connection release() {
- connection c = std::move(_connection);
- _connection = connection{};
- return c;
- }
-
- ///
- /// @returns `true` if the connection is connected to a signal object,
- /// and `false` otherwise.
- bool connected() const {
- return _connection.connected();
- }
-
- /// Disconnect the slot from the connection.
- ///
- /// If the connection represents a slot that is connected to a signal object, calling
- /// this method will disconnect the slot from that object. The result of this operation
- /// is that the slot will stop receiving calls when the signal is invoked.
- void disconnect() {
- _connection.disconnect();
- }
-
- private:
- /// Underlying connection object
- connection _connection;
- };
-
- /// Policy for multi threaded use of signals.
- ///
- /// This policy provides mutex and lock types for use in
- /// a multithreaded environment, where signals and slots
- /// may exists in different threads.
- ///
- /// This policy is used in the `nod::signal` type provided
- /// by the library.
- struct multithread_policy
- {
- using mutex_type = std::mutex;
- using mutex_lock_type = std::unique_lock<mutex_type>;
- /// Function that yields the current thread, allowing
- /// the OS to reschedule.
- static void yield_thread() {
- std::this_thread::yield();
- }
- /// Function that defers a lock to a lock function that prevents deadlock
- static mutex_lock_type defer_lock(mutex_type & m){
- return mutex_lock_type{m, std::defer_lock};
- }
- /// Function that locks two mutexes and prevents deadlock
- static void lock(mutex_lock_type & a,mutex_lock_type & b) {
- std::lock(a,b);
- }
- };
-
- /// Policy for single threaded use of signals.
- ///
- /// This policy provides dummy implementations for mutex
- /// and lock types, resulting in that no synchronization
- /// will take place.
- ///
- /// This policy is used in the `nod::unsafe_signal` type
- /// provided by the library.
- struct singlethread_policy
- {
- /// Dummy mutex type that doesn't do anything
- struct mutex_type{};
- /// Dummy lock type, that doesn't do any locking.
- struct mutex_lock_type
- {
- /// A lock type must be constructible from a
- /// mutex type from the same thread policy.
- explicit mutex_lock_type( mutex_type const& ) {
- }
- };
- /// Dummy implementation of thread yielding, that
- /// doesn't do any actual yielding.
- static void yield_thread() {
- }
- /// Dummy implemention of defer_lock that doesn't
- /// do anything
- static mutex_lock_type defer_lock(mutex_type &m){
- return mutex_lock_type{m};
- }
- /// Dummy implemention of lock that doesn't
- /// do anything
- static void lock(mutex_lock_type &,mutex_lock_type &) {
- }
- };
-
- /// Signal accumulator class template.
- ///
- /// This acts sort of as a proxy for triggering a signal and
- /// accumulating the slot return values.
- ///
- /// This class is not really intended to instantiate by client code.
- /// Instances are aquired as return values of the method `accumulate()`
- /// called on signals.
- ///
- /// @tparam S Type of signal. The signal_accumulator acts
- /// as a type of proxy for a signal instance of
- /// this type.
- /// @tparam T Type of initial value of the accumulate algorithm.
- /// This type must meet the requirements of `CopyAssignable`
- /// and `CopyConstructible`
- /// @tparam F Type of accumulation function.
- /// @tparam A... Argument types of the underlying signal type.
- ///
- template <class S, class T, class F, class...A>
- class signal_accumulator
- {
- public:
- /// Result type when calling the accumulating function operator.
- using result_type = typename std::result_of<F(T, typename S::slot_type::result_type)>::type;
-
- /// Construct a signal_accumulator as a proxy to a given signal
- //
- /// @param signal Signal instance.
- /// @param init Initial value of the accumulate algorithm.
- /// @param func Binary operation function object that will be
- /// applied to all slot return values.
- /// The signature of the function should be
- /// equivalent of the following:
- /// `R func( T1 const& a, T2 const& b )`
- /// - The signature does not need to have `const&`.
- /// - The initial value, type `T`, must be implicitly
- /// convertible to `R`
- /// - The return type `R` must be implicitly convertible
- /// to type `T1`.
- /// - The type `R` must be `CopyAssignable`.
- /// - The type `S::slot_type::result_type` (return type of
- /// the signals slots) must be implicitly convertible to
- /// type `T2`.
- signal_accumulator( S const& signal, T init, F func ) :
- _signal( signal ),
- _init( init ),
- _func( func )
- {}
-
- /// Function call operator.
- ///
- /// Calling this will trigger the underlying signal and accumulate
- /// all of the connected slots return values with the current
- /// initial value and accumulator function.
- ///
- /// When called, this will invoke the accumulator function will
- /// be called for each return value of the slots. The semantics
- /// are similar to the `std::accumulate` algorithm.
- ///
- /// @param args Arguments to propagate to the slots of the
- /// underlying when triggering the signal.
- result_type operator()( A const& ... args ) const {
- return _signal.trigger_with_accumulator( _init, _func, args... );
- }
-
- private:
-
- /// Reference to the underlying signal to proxy.
- S const& _signal;
- /// Initial value of the accumulate algorithm.
- T _init;
- /// Accumulator function.
- F _func;
-
- };
-
- /// Signal template specialization.
- ///
- /// This is the main signal implementation, and it is used to
- /// implement the observer pattern whithout the overhead
- /// boilerplate code that typically comes with it.
- ///
- /// Any function or function object is considered a slot, and
- /// can be connected to a signal instance, as long as the signature
- /// of the slot matches the signature of the signal.
- ///
- /// @tparam P Threading policy for the signal.
- /// A threading policy must provide two type definitions:
- /// - P::mutex_type, this type will be used as a mutex
- /// in the signal_type class template.
- /// - P::mutex_lock_type, this type must implement a
- /// constructor that takes a P::mutex_type as a parameter,
- /// and it must have the semantics of a scoped mutex lock
- /// like std::lock_guard, i.e. locking in the constructor
- /// and unlocking in the destructor.
- ///
- /// @tparam R Return value type of the slots connected to the signal.
- /// @tparam A... Argument types of the slots connected to the signal.
- template <class P, class R, class... A >
- class signal_type<P,R(A...)>
- {
- public:
- /// signals are not copy constructible
- signal_type( signal_type const& ) = delete;
- /// signals are not copy assignable
- signal_type& operator=( signal_type const& ) = delete;
- /// signals are move constructible
- signal_type(signal_type&& other)
- {
- mutex_lock_type lock{other._mutex};
- _slot_count = std::move(other._slot_count);
- _slots = std::move(other._slots);
- if(other._shared_disconnector != nullptr)
- {
- _disconnector = disconnector{ this };
- _shared_disconnector = std::move(other._shared_disconnector);
- // replace the disconnector with our own disconnector
- *static_cast<disconnector*>(_shared_disconnector.get()) = _disconnector;
- }
- }
- /// signals are move assignable
- signal_type& operator=(signal_type&& other)
- {
- auto lock = thread_policy::defer_lock(_mutex);
- auto other_lock = thread_policy::defer_lock(other._mutex);
- thread_policy::lock(lock,other_lock);
-
- _slot_count = std::move(other._slot_count);
- _slots = std::move(other._slots);
- if(other._shared_disconnector != nullptr)
- {
- _disconnector = disconnector{ this };
- _shared_disconnector = std::move(other._shared_disconnector);
- // replace the disconnector with our own disconnector
- *static_cast<disconnector*>(_shared_disconnector.get()) = _disconnector;
- }
- return *this;
- }
-
- /// signals are default constructible
- signal_type() :
- _slot_count(0)
- {}
-
- // Destruct the signal object.
- ~signal_type() {
- invalidate_disconnector();
- }
-
- /// Type that will be used to store the slots for this signal type.
- using slot_type = std::function<R(A...)>;
- /// Type that is used for counting the slots connected to this signal.
- using size_type = typename std::vector<slot_type>::size_type;
-
-
- /// Connect a new slot to the signal.
- ///
- /// The connected slot will be called every time the signal
- /// is triggered.
- /// @param slot The slot to connect. This must be a callable with
- /// the same signature as the signal itself.
- /// @return A connection object is returned, and can be used to
- /// disconnect the slot.
- template <class T>
- connection connect( T&& slot ) {
- mutex_lock_type lock{ _mutex };
- _slots.push_back( std::forward<T>(slot) );
- std::size_t index = _slots.size()-1;
- if( _shared_disconnector == nullptr ) {
- _disconnector = disconnector{ this };
- _shared_disconnector = std::shared_ptr<detail::disconnector>{&_disconnector, detail::no_delete};
- }
- ++_slot_count;
- return connection{ _shared_disconnector, index };
- }
-
- /// Function call operator.
- ///
- /// Calling this is how the signal is triggered and the
- /// connected slots are called.
- ///
- /// @note The slots will be called in the order they were
- /// connected to the signal.
- ///
- /// @param args Arguments that will be propagated to the
- /// connected slots when they are called.
- void operator()( A const&... args ) const {
- for( auto const& slot : copy_slots() ) {
- if( slot ) {
- slot( args... );
- }
- }
- }
-
- /// Construct a accumulator proxy object for the signal.
- ///
- /// The intended purpose of this function is to create a function
- /// object that can be used to trigger the signal and accumulate
- /// all the slot return values.
- ///
- /// The algorithm used to accumulate slot return values is similar
- /// to `std::accumulate`. A given binary function is called for
- /// each return value with the parameters consisting of the
- /// return value of the accumulator function applied to the
- /// previous slots return value, and the current slots return value.
- /// A initial value must be provided for the first slot return type.
- ///
- /// @note This can only be used on signals that have slots with
- /// non-void return types, since we can't accumulate void
- /// values.
- ///
- /// @tparam T The type of the initial value given to the accumulator.
- /// @tparam F The accumulator function type.
- /// @param init Initial value given to the accumulator.
- /// @param op Binary operator function object to apply by the accumulator.
- /// The signature of the function should be
- /// equivalent of the following:
- /// `R func( T1 const& a, T2 const& b )`
- /// - The signature does not need to have `const&`.
- /// - The initial value, type `T`, must be implicitly
- /// convertible to `R`
- /// - The return type `R` must be implicitly convertible
- /// to type `T1`.
- /// - The type `R` must be `CopyAssignable`.
- /// - The type `S::slot_type::result_type` (return type of
- /// the signals slots) must be implicitly convertible to
- /// type `T2`.
- template <class T, class F>
- signal_accumulator<signal_type, T, F, A...> accumulate( T init, F op ) const {
- static_assert( std::is_same<R,void>::value == false, "Unable to accumulate slot return values with 'void' as return type." );
- return { *this, init, op };
- }
-
-
- /// Trigger the signal, calling the slots and aggregate all
- /// the slot return values into a container.
- ///
- /// @tparam C The type of container. This type must be
- /// `DefaultConstructible`, and usable with
- /// `std::back_insert_iterator`. Additionally it
- /// must be either copyable or moveable.
- /// @param args The arguments to propagate to the slots.
- template <class C>
- C aggregate( A const&... args ) const {
- static_assert( std::is_same<R,void>::value == false, "Unable to aggregate slot return values with 'void' as return type." );
- C container;
- auto iterator = std::back_inserter( container );
- for( auto const& slot : copy_slots() ) {
- if( slot ) {
- (*iterator) = slot( args... );
- }
- }
- return container;
- }
-
- /// Count the number of slots connected to this signal
- /// @returns The number of connected slots
- size_type slot_count() const {
- return _slot_count;
- }
-
- /// Determine if the signal is empty, i.e. no slots are connected
- /// to it.
- /// @returns `true` is returned if the signal has no connected
- /// slots, and `false` otherwise.
- bool empty() const {
- return slot_count() == 0;
- }
-
- /// Disconnects all slots
- /// @note This operation invalidates all scoped_connection objects
- void disconnect_all_slots() {
- mutex_lock_type lock{ _mutex };
- _slots.clear();
- _slot_count = 0;
- invalidate_disconnector();
- }
-
- private:
- template<class, class, class, class...> friend class signal_accumulator;
- /// Thread policy currently in use
- using thread_policy = P;
- /// Type of mutex, provided by threading policy
- using mutex_type = typename thread_policy::mutex_type;
- /// Type of mutex lock, provided by threading policy
- using mutex_lock_type = typename thread_policy::mutex_lock_type;
-
- /// Invalidate the internal disconnector object in a way
- /// that is safe according to the current thread policy.
- ///
- /// This will effectively make all current connection objects to
- /// to this signal incapable of disconnecting, since they keep a
- /// weak pointer to the shared disconnector object.
- void invalidate_disconnector() {
- // If we are unlucky, some of the connected slots
- // might be in the process of disconnecting from other threads.
- // If this happens, we are risking to destruct the disconnector
- // object managed by our shared pointer before they are done
- // disconnecting. This would be bad. To solve this problem, we
- // discard the shared pointer (that is pointing to the disconnector
- // object within our own instance), but keep a weak pointer to that
- // instance. We then stall the destruction until all other weak
- // pointers have released their "lock" (indicated by the fact that
- // we will get a nullptr when locking our weak pointer).
- std::weak_ptr<detail::disconnector> weak{_shared_disconnector};
- _shared_disconnector.reset();
- while( weak.lock() != nullptr ) {
- // we just yield here, allowing the OS to reschedule. We do
- // this until all threads has released the disconnector object.
- thread_policy::yield_thread();
- }
- }
-
- /// Retrieve a copy of the current slots
- ///
- /// It's useful and necessary to copy the slots so we don't need
- /// to hold the lock while calling the slots. If we hold the lock
- /// we prevent the called slots from modifying the slots vector.
- /// This simple "double buffering" will allow slots to disconnect
- /// themself or other slots and connect new slots.
- std::vector<slot_type> copy_slots() const
- {
- mutex_lock_type lock{ _mutex };
- return _slots;
- }
-
- /// Implementation of the signal accumulator function call
- template <class T, class F>
- typename signal_accumulator<signal_type, T, F, A...>::result_type trigger_with_accumulator( T value, F& func, A const&... args ) const {
- for( auto const& slot : copy_slots() ) {
- if( slot ) {
- value = func( value, slot( args... ) );
- }
- }
- return value;
- }
-
- /// Implementation of the disconnection operation.
- ///
- /// This is private, and only called by the connection
- /// objects created when connecting slots to this signal.
- /// @param index The slot index of the slot that should
- /// be disconnected.
- void disconnect( std::size_t index ) {
- mutex_lock_type lock( _mutex );
- assert( _slots.size() > index );
- if( _slots[ index ] != nullptr ) {
- --_slot_count;
- }
- _slots[ index ] = slot_type{};
- while( _slots.size()>0 && !_slots.back() ) {
- _slots.pop_back();
- }
- }
-
- /// Implementation of the shared disconnection state
- /// used by all connection created by signal instances.
- ///
- /// This inherits the @ref detail::disconnector interface
- /// for type erasure.
- struct disconnector :
- detail::disconnector
- {
- /// Default constructor, resulting in a no-op disconnector.
- disconnector() :
- _ptr(nullptr)
- {}
-
- /// Create a disconnector that works with a given signal instance.
- /// @param ptr Pointer to the signal instance that the disconnector
- /// should work with.
- disconnector( signal_type<P,R(A...)>* ptr ) :
- _ptr( ptr )
- {}
-
- /// Disconnect a given slot on the current signal instance.
- /// @note If the instance is default constructed, or created
- /// with `nullptr` as signal pointer this operation will
- /// effectively be a no-op.
- /// @param index The index of the slot to disconnect.
- void operator()( std::size_t index ) const override {
- if( _ptr ) {
- _ptr->disconnect( index );
- }
- }
-
- /// Pointer to the current signal.
- signal_type<P,R(A...)>* _ptr;
- };
-
- /// Mutex to synchronize access to the slot vector
- mutable mutex_type _mutex;
- /// Vector of all connected slots
- std::vector<slot_type> _slots;
- /// Number of connected slots
- size_type _slot_count;
- /// Disconnector operation, used for executing disconnection in a
- /// type erased manner.
- disconnector _disconnector;
- /// Shared pointer to the disconnector. All connection objects has a
- /// weak pointer to this pointer for performing disconnections.
- std::shared_ptr<detail::disconnector> _shared_disconnector;
- };
-
- // Implementation of the disconnect operation of the connection class
- inline void connection::disconnect() {
- auto ptr = _weak_disconnector.lock();
- if( ptr ) {
- (*ptr)( _index );
- }
- _weak_disconnector.reset();
- }
-
- /// Signal type that is safe to use in multithreaded environments,
- /// where the signal and slots exists in different threads.
- /// The multithreaded policy provides mutexes and locks to synchronize
- /// access to the signals internals.
- ///
- /// This is the recommended signal type, even for single threaded
- /// environments.
- template <class T> using signal = signal_type<multithread_policy, T>;
-
- /// Signal type that is unsafe in multithreaded environments.
- /// No synchronizations are provided to the signal_type for accessing
- /// the internals.
- ///
- /// Only use this signal type if you are sure that your environment is
- /// single threaded and performance is of importance.
- template <class T> using unsafe_signal = signal_type<singlethread_policy, T>;
-} // namespace nod
-
-#endif // IG_NOD_INCLUDE_NOD_HPP
generated by cgit v1.2.3 (git 2.25.1) at 2026-04-29 20:53:21 +0000