observers.hpp File Reference

#include <array>
#include <concepts>
#include <cstddef>
#include <exception>
#include <functional>
#include <tuple>
#include <type_traits>
#include <utility>
#include <format>
#include <string_view>
#include "serif/utils/dependencies/detail/schema.hpp"

Include dependency graph for observers.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	serif::utils::dependencies::NodeObserver< KeyT, BeforeT, AfterT >
struct	serif::utils::dependencies::AllNodesObserver< BeforeT, AfterT >
	One registration can inspect every result without building a graph-sized observer tuple. More...
struct	serif::utils::dependencies::EdgeObserver< InputT, ConsumerT, FunctionT >
class	serif::utils::dependencies::detail::NodeObservation< BeforeT, AfterT >
	Each started hook owns one invocation state and finishes once, including on exceptional exit. More...
class	serif::utils::dependencies::Observers< Registrations >
	Own registrations; execution state lasts for one invocation and is never part of the numerical cache. More...
struct	serif::utils::dependencies::NoGraphObservers
	Default high-level binding adds no observation storage, timers, or callback work. More...
struct	serif::utils::dependencies::detail::ValidObservers< ObserversT, GraphT, ContextT, Valid >
struct	serif::utils::dependencies::detail::ValidObservers< Observers< Registrations... >, GraphT, ContextT, true >
struct	std::formatter< serif::utils::dependencies::NodeOutcome >

Namespaces
namespace	serif
namespace	serif::utils
namespace	serif::utils::dependencies
namespace	serif::utils::dependencies::detail

Concepts
concept	serif::utils::dependencies::NodeObserverCallbacks
	Completion must be safe during stack unwinding and receives the state created by the before hook.
concept	serif::utils::dependencies::KeyedNodeObserverCallbacks
	An all-node callback receives the compiled result identity before creating its invocation state.
concept	serif::utils::dependencies::ObserversFor
	Reject unknown nodes, nonexistent edges, and callbacks that cannot observe the graph's immutable values.

Enumerations
enum class	serif::utils::dependencies::NodeOutcome { serif::utils::dependencies::completed , serif::utils::dependencies::rejected , serif::utils::dependencies::exception }
	Describe a node invocation, independently of whether the whole graph request is later accepted. More...

Functions
template<typename KeyT, typename BeforeT, typename AfterT>
decltype(auto)	serif::utils::dependencies::detail::begin_node (NodeObserver< KeyT, BeforeT, AfterT > &observer)
	Preserve the existing nullary callback contract for individually selected nodes.
template<typename KeyT, typename BeforeT, typename AfterT>
decltype(auto)	serif::utils::dependencies::detail::begin_node (AllNodesObserver< BeforeT, AfterT > &observer)
	Bind the identity once so generic registrations use the same exception-safe invocation scope.
template<typename InputT, typename ConsumerT, typename ObserverT, typename ValueT>
void	serif::utils::dependencies::detail::observe_input (ObserverT &, const ValueT &)
	Unrelated registrations do not observe this edge.
template<typename InputT, typename ConsumerT, typename FunctionT, typename ValueT>
void	serif::utils::dependencies::detail::observe_input (EdgeObserver< InputT, ConsumerT, FunctionT > &observer, const ValueT &value)
	Edge observers read the numerical value even when its consumer receives an owning handle.
template<typename KeyT, typename BeforeT, typename AfterT> requires NodeObserverCallbacks<std::decay_t<BeforeT>, std::decay_t<AfterT>> && std::constructible_from<std::decay_t<BeforeT>, BeforeT> && std::constructible_from<std::decay_t<AfterT>, AfterT>
auto	serif::utils::dependencies::observe_node (BeforeT &&before, AfterT &&after)
	Bind before/after callbacks to a result key; callback captures determine any external storage lifetime.
template<typename BeforeT, typename AfterT> requires std::constructible_from<std::decay_t<BeforeT>, BeforeT> && std::constructible_from<std::decay_t<AfterT>, AfterT>
auto	serif::utils::dependencies::observe_nodes (BeforeT &&before, AfterT &&after)
	Observe all executed nodes; cache construction checks the callback contract for every result key.
template<typename InputT, typename ConsumerT, typename FunctionT> requires std::constructible_from<std::decay_t<FunctionT>, FunctionT>
auto	serif::utils::dependencies::observe_edge (FunctionT &&function)
	Bind a read-only callback to one input of one consumer; graph construction validates the edge and value type.
template<typename... Registrations> requires (detail::is_observer_v<std::remove_cvref_t<Registrations>> && ...) && (std::constructible_from<std::remove_cvref_t<Registrations>, Registrations> && ...)
auto	serif::utils::dependencies::make_observers (Registrations &&... observers)
	Collect any number of registrations, including several observers of the same node or edge.
template<typename GraphT, typename BindingsT, typename KeyT, typename BeforeT, typename AfterT>
consteval bool	serif::utils::dependencies::detail::valid_observer (NodeObserver< KeyT, BeforeT, AfterT > *)
	Nodes are identified by result keys, including constant computations without inputs.
template<typename BeforeT, typename AfterT, typename... Keys>
consteval bool	serif::utils::dependencies::detail::valid_all_nodes (KeyList< Keys... >)
	Use a bounded array scan rather than a graph-sized fold expression at the compiler's nesting limit.
template<typename GraphT, typename BindingsT, typename BeforeT, typename AfterT>
consteval bool	serif::utils::dependencies::detail::valid_observer (AllNodesObserver< BeforeT, AfterT > *)
	A generic callback must accept every node, including constant computations without inputs.
template<typename GraphT, typename BindingsT, typename InputT, typename ConsumerT, typename FunctionT>
consteval bool	serif::utils::dependencies::detail::valid_observer (EdgeObserver< InputT, ConsumerT, FunctionT > *)
	Use declared inputs to include source edges as well as computed prerequisites.

Variables
template<typename T>
constexpr bool	serif::utils::dependencies::detail::is_observer_v = false
template<typename KeyT, typename BeforeT, typename AfterT>
constexpr bool	serif::utils::dependencies::detail::is_observer_v< NodeObserver< KeyT, BeforeT, AfterT > > = true
template<typename BeforeT, typename AfterT>
constexpr bool	serif::utils::dependencies::detail::is_observer_v< AllNodesObserver< BeforeT, AfterT > > = true
template<typename InputT, typename ConsumerT, typename FunctionT>
constexpr bool	serif::utils::dependencies::detail::is_observer_v< EdgeObserver< InputT, ConsumerT, FunctionT > > = true
template<typename ObserverT, typename KeyT>
constexpr bool	serif::utils::dependencies::detail::observes_node_v = false
template<typename KeyT, typename BeforeT, typename AfterT>
constexpr bool	serif::utils::dependencies::detail::observes_node_v< NodeObserver< KeyT, BeforeT, AfterT >, KeyT > = true
template<typename BeforeT, typename AfterT, typename KeyT>
constexpr bool	serif::utils::dependencies::detail::observes_node_v< AllNodesObserver< BeforeT, AfterT >, KeyT > = true