* Emits the Signal, which causes all connected slots to be called, * as long as they are not blocked. * * The arguments provided to emi

Re-evaluates the value of the Binding and notifies all dependants of the change. */

* Check whether the connection of this ConnectionHandle is active. * * @return true if the ConnectionHandle refers to an active Signal

* Disconnect a previously connected slot. * * After the slot was successfully disconnected, the ConnectionHandle will no * longer be ac

parses a comma separated list of words after a pattern in one of the arguments in argv

Erase all the values in the array and thus free up all indices too

The number entries currently in the array, not all necessarily correspond to valid indices, use "indexAtEntry" to translate from an entry index to a o

Returns the current value of the Binding. */

* Checks whether the connection is currently blocked. * * To change the blocked state of a connection, call blockConnection(). * *

locates a flag on the command line

* @brief Evaluate the deferred connections. * * This function is responsible for evaluating and executing deferred connections. * This

* This function evaluates all Binding instances that were constructed with this * evaluator, in the order they were inserted. * * It wi

Erase the value at the specified index and free up the index again

* Sets the block state of the connection. * If a connection is blocked, emitting the Signal will no longer call this * connections slot, unt

the only functions I'm willing to leave in the interface - available for inlining

Convert an entry index into a GenerationalIndex, if possible otherwise returns nullopt

* Sets the block state of the connection. * If a connection is blocked, emitting the Signal will no longer call this * connections slot, unt

* Checks whether the connection is currently blocked. * * To change the blocked state of a connection, call ConnectionHandle::block. *

* @brief Disconnects the binding from this Property * * If this Property has a binding, it will no longer update it. * Otherwise, this

parses an option and returns the string after the '=' character

Set the function that should be used to notify * associated properties when the Binding re-evaluates. */

* Disconnect the slot. * * When this function is called, the function that was passed to Signal::connect * to create this ConnectionHan

NOLINTEND(*-avoid-c-arrays)

* Returns true if this Property has a binding associated with it. */

the implementation of parseOption()

Note: This function is marked with noexcept but may theoretically encounter an exception and terminate the program if locking the mutex fails. If this

* Disconnect all previously connected functions. * * All currently active ConnectionHandles that belong to this Signal will no * longer

overridden by Binding

* This function exists to intentionally silence the [[nodiscard]] warning generated when connecting. * * In cases where you know for certain

the main function that does all the filtering and test running

* Assign a new value to this Property. * * If the new value is equal_to the existing value, the value will not be * changed and no Sign

* @brief Construct a new Binding with a specific evaluator. * * @param rootNode Represents that expression contained in the Binding. *

* @brief Construct a new Binding with an immediate mode evaluator. * * @param rootNode Represents that expression contained in the Binding.

A BindingEvaluator can be default constructed */

* Constructs a new ConnectionBlocker and blocks the connection this ConnectionHandle * refers to. * * @throw std::out_of_range If the c

ConnectionEvaluators are default constructible */

* A ConnectionHandle can be default constructed. * In this case the ConnectionHandle will not reference any active connection (i.e. isActive() wi