Live Cells C++
Reactive Programming for C++
Loading...
Searching...
No Matches
live_cells::dynamic_mutable_compute_cell_state< F, R, ValueType > Class Template Reference

Maintains the state of a dynamic_mutable_compute_cell. More...

#include <dynamic_mutable_compute_cell.hpp>

Inheritance diagram for live_cells::dynamic_mutable_compute_cell_state< F, R, ValueType >:
Collaboration diagram for live_cells::dynamic_mutable_compute_cell_state< F, R, ValueType >:

Public Member Functions

template<typename T , typename U >
 dynamic_mutable_compute_cell_state (key_ref key, T &&compute, U &&reverse)
 Create the state for a dynamic mutable computed cell.
 
- Public Member Functions inherited from live_cells::mutable_compute_cell_state< T >
 mutable_compute_cell_state (key_ref key, const std::unordered_set< cell > &arguments)
 Create the state for a mutable computed cell.
 
value ()
 Get the value of the cell.
 
void value (T value)
 Set the value of the cell.
 
void will_update (const key_ref &k) override
 Notifies this observer that the value of the Cell identified by k is going to change.
 
void update (const key_ref &k, bool changed) override
 Notifies this observer that the value of the Cell identified by k has changed.
 
void init () override
 Add this state as an observer to the compute function arguments.
 
void pause () override
 Remove this state from the observers of the compute function arguments.
 
- Public Member Functions inherited from live_cells::mutable_cell_state< T >
 mutable_cell_state (key_ref key, T value)
 Create a mutable cell state with the value initialized to value.
 
value ()
 Get the value of the cell.
 
void value (T value)
 Set the value of the cell and notify its observers.
 
 cell_state (key_ref k)
 Create a cell state with a given key.
 
- Public Member Functions inherited from live_cells::cell_state
 cell_state (key_ref k)
 Create a cell state with a given key.
 
cell_stateoperator= (const cell_state &other)=delete
 
virtual void add_observer (observer::ref o)
 Add an observer to the cell's set of observers.
 
virtual void remove_observer (observer::ref o)
 Remove an observer from the cell's set of observers.
 
virtual void notify_will_update ()
 Notify the observers that the cell's value will change.
 
virtual void notify_update (bool did_change=true)
 Notify the observers that the cell's value has changed.
 

Protected Types

typedef ValueType value_type
 
typedef mutable_compute_cell_state< ValueTypeparent
 Shorthand for parent class.
 

Protected Member Functions

ValueType compute () override
 Compute the value of the cell as a function of its argument cells.
 
void reverse_compute (ValueType value) override
 
- Protected Member Functions inherited from live_cells::mutable_compute_cell_state< T >
virtual void reverse_compute (T value)=0
 Perform the reverse computation.
 
std::shared_ptr< observerobserver_ptr ()
 Get an observer::ref for this, that can be passed to add_observer() and remove_observer() of the Cell concept.
 
- Protected Member Functions inherited from live_cells::mutable_cell_state< T >
void silent_set (T value)
 Set the cell's value without notifying observers.
 
void add_to_batch ()
 Add this state to the list of mutable cells that were updating during the current batch update.
 
- Protected Member Functions inherited from live_cells::cell_state
bool is_active () const
 Does the cell have at least one observer?
 
- Protected Member Functions inherited from live_cells::observer_cell_state
void init_observer_state ()
 Initialize the cell observation state.
 
void pause_observer_state ()
 Pause the cell observation state.
 
void handle_will_update (const std::invocable auto &notify_will_update)
 Handle a observer::will_update call.
 
void handle_will_update (const std::invocable auto &pre_update, const std::invocable auto &notify_will_update)
 Handle a observer::will_update call.
 
void handle_update (bool changed, const std::invocable< bool > auto &notify_update)
 Handle an observer::update call.
 
void handle_update (bool changed, const std::invocable auto &did_change, const std::invocable< bool > auto &notify_update, const std::invocable auto &post_update)
 Handle an observer::update call.
 

Additional Inherited Members

- Public Types inherited from live_cells::cell_state
typedef std::shared_ptr< cell_stateref
 Shared pointer to a cell_state.
 
- Public Types inherited from live_cells::observer
typedef std::shared_ptr< observerref
 Shared pointer to an observer.
 
- Static Protected Member Functions inherited from live_cells::mutable_cell_state< T >
static bool is_batch_update ()
 Is a batch update of mutable cells currently in effect?
 
- Protected Attributes inherited from live_cells::mutable_compute_cell_state< T >
std::unordered_set< cellarguments
 Set of argument cells referenced by the value computation function.
 
bool reverse = false
 Is the value of the cell being set, and hence a reverse computation being performed?
 
bool computed = true
 Is the cell's value the computed value (true) or a value that was set (false).
 
- Protected Attributes inherited from live_cells::cell_state
key_ref key_
 Key identifying the cell corresponding to this state.
 
std::unordered_map< observer::ref, std::size_t > observers
 The set of observers observing changes to the values in the cell corresponding to this state.
 
- Protected Attributes inherited from live_cells::observer_cell_state
bool stale = true
 Does the value have to be recomputed?
 
bool updating = false
 Are the argument cells in the process of updating their values?
 

Detailed Description

template<std::invocable F, typename R, typename ValueType = std::invoke_result_t<F>>
class live_cells::dynamic_mutable_compute_cell_state< F, R, ValueType >

Maintains the state of a dynamic_mutable_compute_cell.

Constructor & Destructor Documentation

◆ dynamic_mutable_compute_cell_state()

template<std::invocable F, typename R , typename ValueType = std::invoke_result_t<F>>
template<typename T , typename U >
live_cells::dynamic_mutable_compute_cell_state< F, R, ValueType >::dynamic_mutable_compute_cell_state ( key_ref key,
T && compute,
U && reverse )
inline

Create the state for a dynamic mutable computed cell.

Parameters
keyKey identifying cell
computeValue computation function
reverseReverse computation function

Member Function Documentation

◆ compute()

template<std::invocable F, typename R , typename ValueType = std::invoke_result_t<F>>
ValueType live_cells::dynamic_mutable_compute_cell_state< F, R, ValueType >::compute ( )
inlineoverrideprotectedvirtual

Compute the value of the cell as a function of its argument cells.

Subclasses should override this method with a method that performs the computation logic for the cell.

Returns
The computed value

Implements live_cells::mutable_compute_cell_state< T >.


The documentation for this class was generated from the following file: