Synchronizer

#include <icy/synchronizer.h>

class Synchronizer

Defined in src/base/include/icy/synchronizer.h:39

Inherits: Runner

This class inherits the Runner interface and may be used with any implementation that's powered by an asynchronous Runner.

List of all members

Name	Kind	Owner
`Synchronizer`	`function`	Declared here
`Synchronizer`	`function`	Declared here
`Synchronizer`	`function`	Declared here
`~Synchronizer`	`function`	Declared here
`post`	`function`	Declared here
`start`	`function`	Declared here
`start`	`function`	Declared here
`cancel`	`function`	Declared here
`close`	`function`	Declared here
`handle`	`function`	Declared here
`_handle`	`variable`	Declared here
`_postMutex`	`variable`	Declared here
`async`	`function`	Declared here
`Runner`	`function`	Inherited from `Runner`
`~Runner`	`function`	Inherited from `Runner`
`start`	`function`	Inherited from `Runner`
`running`	`function`	Inherited from `Runner`
`cancel`	`function`	Inherited from `Runner`
`cancelled`	`function`	Inherited from `Runner`
`repeating`	`function`	Inherited from `Runner`
`setRepeating`	`function`	Inherited from `Runner`
`async`	`function`	Inherited from `Runner`
`tid`	`function`	Inherited from `Runner`
`waitForExit`	`function`	Inherited from `Runner`
`_context`	`variable`	Inherited from `Runner`
`Runner`	`function`	Inherited from `Runner`
`operator=`	`function`	Inherited from `Runner`
`Runner`	`function`	Inherited from `Runner`
`operator=`	`function`	Inherited from `Runner`

Inherited from `Runner`

Kind	Name	Description
`function`	`Runner`
`function`	`~Runner` virtual
`function`	`start` virtual	Starts the asynchronous context with the given callback. The callback must remain valid for the lifetime of the `Runner`.
`function`	`running` const	Returns true if the async context is currently running.
`function`	`cancel`	Signals the async context to stop at the earliest opportunity.
`function`	`cancelled` const	Returns true if the context has been cancelled. The implementation is responsible for exiting as soon as possible after cancellation.
`function`	`repeating` const	Returns true if the runner is in repeating mode.
`function`	`setRepeating`	Enables or disables repeating mode. When repeating, the target function is invoked repeatedly until `cancel()` is called. This normalizes behaviour across thread-based and event-loop-based `Runner` implementations. Must be called before `start()`.
`function`	`async` virtual const	Returns true if the implementation is thread-based.
`function`	`tid` const	Returns the native thread ID of the thread running the async context.
`function`	`waitForExit`	Blocks until the async context exits or the timeout elapses. The context should be cancelled before calling this method. Must be called from outside the runner's own thread to avoid deadlock.
`variable`	`_context`	Shared pointer to the internal Context.
`function`	`Runner`	NonCopyable and NonMovable.
`function`	`operator=`	Deleted assignment operator.
`function`	`Runner`	Deleted constructor.
`function`	`operator=`	Deleted assignment operator.

Public Methods

Return	Name	Description
	`Synchronizer`	Creates a synchronizer attached to the given event loop without a callback. Call `start()` separately to register the callback before using `post()`.
	`Synchronizer`	Creates and immediately starts a synchronizer with a single callback function. The target is invoked from the event loop context each time `post()` is called.
	`Synchronizer` inline explicit	Creates and immediately starts a synchronizer with a variadic callback.
	`~Synchronizer` virtual	Destructor.
`void`	`post`	Send a synchronization request to the event loop. Call this each time you want the target method called synchronously. The synchronous method will be called on next iteration. This is not atomic, so do not expect a callback for every request.
`void`	`start` inline	Starts the synchronizer with a variadic callback function. The callback is invoked from the event loop each time `post()` is called. Throws `std::logic_error` if already running or if the handle is null.
`void`	`start` virtual override	Starts the synchronizer with a `std::function` callback. Overrides `Runner::start`; delegates to the variadic `start` template.
`void`	`cancel` virtual	Cancels the synchronizer, signalling the associated callback to stop. A subsequent `post()` is needed to wake up the event loop so it can process the cancellation.
`void`	`close` virtual	Cancels the synchronizer and closes the underlying `uv_async_t` handle. Safe to call multiple times; no-op if already closed.
`uv::Handle`< uv_async_t > &	`handle`	Returns a reference to the underlying libuv async handle.

Synchronizer

Synchronizer(uv::Loop * loop)

Defined in src/base/include/icy/synchronizer.h:47

Creates a synchronizer attached to the given event loop without a callback. Call start() separately to register the callback before using post().

Parameters

Parameter	Type	Description
`loop`	`uv::Loop` *	Event loop to attach the async handle to.

Synchronizer

Synchronizer(std::function< void()> target, uv::Loop * loop = uv::defaultLoop())

Defined in src/base/include/icy/synchronizer.h:53

Creates and immediately starts a synchronizer with a single callback function. The target is invoked from the event loop context each time post() is called.

Parameters

Parameter	Type	Description
`target`	`std::function< void()>`	Callback to invoke on each event loop wakeup.
`loop`	`uv::Loop` *	Event loop to attach the async handle to.

Synchronizer

inline explicit

template<typename Function, typename... Args> inline explicit Synchronizer(Function && func, Args &&... args, uv::Loop * loop = uv::defaultLoop())

Defined in src/base/include/icy/synchronizer.h:62

Creates and immediately starts a synchronizer with a variadic callback.

Parameters

Parameter	Type	Description
`func`	`Function &&`	Callable to invoke on each event loop wakeup.
`args`	`Args &&...`	Arguments forwarded to `func`.
`loop`	`uv::Loop` *	Event loop to attach the async handle to.

~Synchronizer

virtual

virtual ~Synchronizer()

Defined in src/base/include/icy/synchronizer.h:70

Destructor.

post

void post()

Defined in src/base/include/icy/synchronizer.h:76

Send a synchronization request to the event loop. Call this each time you want the target method called synchronously. The synchronous method will be called on next iteration. This is not atomic, so do not expect a callback for every request.

start

inline

template<typename Function, typename... Args> inline void start(Function && func, Args &&... args)

Defined in src/base/include/icy/synchronizer.h:86

Starts the synchronizer with a variadic callback function. The callback is invoked from the event loop each time post() is called. Throws std::logic_error if already running or if the handle is null.

Parameters

Parameter	Type	Description
`func`	`Function &&`	Callable to invoke on each event loop wakeup.
`args`	`Args &&...`	Arguments forwarded to `func`.

start

virtual override

virtual void start(std::function< void()> func) override

Defined in src/base/include/icy/synchronizer.h:132

Starts the synchronizer with a std::function callback. Overrides Runner::start; delegates to the variadic start template.

Reimplements

Runner::start

Parameters

Parameter	Type	Description
`func`	`std::function< void()>`	Callback invoked from the event loop on each `post()` call.

cancel

virtual

virtual void cancel()

Defined in src/base/include/icy/synchronizer.h:136

Cancels the synchronizer, signalling the associated callback to stop. A subsequent post() is needed to wake up the event loop so it can process the cancellation.

close

virtual

virtual void close()

Defined in src/base/include/icy/synchronizer.h:140

Cancels the synchronizer and closes the underlying uv_async_t handle. Safe to call multiple times; no-op if already closed.

handle

uv::Handle< uv_async_t > & handle()

Defined in src/base/include/icy/synchronizer.h:144

Returns a reference to the underlying libuv async handle.

Returns

Reference to the uv::Handle<uv_async_t>.

Protected Attributes

Return	Name	Description
`uv::Handle`< uv_async_t >	`_handle`
`std::mutex`	`_postMutex`	Serializes `post()` (any thread) against `close()`. The handle context uses a non-atomic intrusive refcount owned by the loop thread, so `post()` must never copy the context pointer; it reads the raw handle under this mutex instead.

_handle

uv::Handle< uv_async_t > _handle

Type: uv::Handle< uv_async_t >

Defined in src/base/include/icy/synchronizer.h:149

_postMutex

std::mutex _postMutex

Defined in src/base/include/icy/synchronizer.h:155

Serializes post() (any thread) against close(). The handle context uses a non-atomic intrusive refcount owned by the loop thread, so post() must never copy the context pointer; it reads the raw handle under this mutex instead.

Protected Methods

Return	Name	Description
`bool`	`async` virtual const override	Returns true if the implementation is thread-based.

async

virtual const override

virtual bool async() const override

Defined in src/base/include/icy/synchronizer.h:147

Returns true if the implementation is thread-based.

Returns

True for thread-backed runners, false for event-loop-driven runners.

Reimplements

Runner::async

List of all members

Inherited from Runner

Public Methods

Synchronizer

Parameters

Synchronizer

Parameters

Synchronizer

Parameters

~Synchronizer

post

start

Parameters

start

Reimplements

Parameters

cancel

close

handle

Returns

Protected Attributes

_handle

_postMutex

Protected Methods

async

Returns

Reimplements

Inherited from `Runner`