| Clive_cells::argument_tracker | |
| ▼CBase | |
| Clive_cells::changes_only_cell_state< Base > | Mixin that modifies a compute_cell_state subclass to only notify its observers if the new value of the cell is not equal (!=) to the previous value |
| Clive_cells::batch_update | Defer changes to the values of mutable cells |
| Clive_cells::cell | Dynamically typed Cell container |
| Clive_cells::changes_only_option | Cell option specifying that the cell, to which it is applied, should only notify its observers when its new value is not equal (by ==) to its previous value |
| Clive_cells::constant_cell< T > | A cell which holds a constant value |
| Clive_cells::dependent_cell< Ts > | Provides an interface for a cell with a value that is dependent on one or more argument cells |
| ▼Clive_cells::dependent_cell< Ts... > | |
| ▼Clive_cells::compute_cell_base< F, Os... > | |
| Clive_cells::mutable_cell_view_base< F, R, Os > | A stateless mutable computed cell that does not cache its own value |
| Clive_cells::compute_cell_base< F, Ts > | A cell with a value that is a function of one or more argument cells |
| Clive_cells::dynamic_compute_state< F > | Defines the computation function of the state of a dynamic_compute_cell |
| ▼Cstd::enable_shared_from_this | |
| ▼Clive_cells::cell_state | Maintains the state of a stateful cell |
| ▼Clive_cells::compute_cell_state< dynamic_compute_state< F > > | |
| ▼Clive_cells::dynamic_compute_cell_state< F > | Maintains the state of a dynamic_compute_cell |
| ▼Clive_cells::changes_only_cell_state< dynamic_compute_cell_state< F > > | |
| Clive_cells::dynamic_compute_changes_only_cell_state< F > | A dynamic_compute_cell_state that only notifies the observers of the cell if the new value of the cell is not equal to the previous value |
| ▼Clive_cells::compute_cell_state< store_cell_compute_state< C > > | |
| ▼Clive_cells::store_cell_state< C > | Maintains the state of a store_cell |
| ▼Clive_cells::changes_only_cell_state< store_cell_state< C > > | |
| Clive_cells::store_changes_only_cell_state< C > | A store_cell_state that only notifies the observers of the cell if the new value of the cell is not equal to its previous value |
| Clive_cells::mutable_cell_state< std::invoke_result_t< F > > | |
| Clive_cells::compute_cell_state< C > | Cell state for a cell which computes a value as a function of one or more argument cells |
| ▼Clive_cells::mutable_cell_state< T > | Maintains the state of a mutable_cell |
| ▼Clive_cells::mutable_compute_cell_state< std::invoke_result_t< F > > | |
| ▼Clive_cells::static_mutable_compute_cell_state< F, R > | Maintains the state for a static_mutable_compute_cell |
| ▼Clive_cells::changes_only_cell_state< static_mutable_compute_cell_state< F, R > > | |
| Clive_cells::static_mutable_compute_changes_only_cell_state< F, R > | A static_mutable_compute_cell_state that only notifies the observers of the cell when the cell's value has actually changed |
| ▼Clive_cells::mutable_compute_cell_state< T > | Maintains the state of a mutable computed cell |
| ▼Clive_cells::dynamic_mutable_compute_cell_state< F, R, ValueType > | Maintains the state of a dynamic_mutable_compute_cell |
| ▼Clive_cells::changes_only_cell_state< dynamic_mutable_compute_cell_state< F, R > > | |
| Clive_cells::dynamic_mutable_compute_changes_only_cell_state< F, R > | A dynamic_mutable_compute_cell_state that only notifies the observers of the cell if its value has actually changed |
| Clive_cells::peek_cell_state< C > | Maintains the state of a peek_cell |
| Clive_cells::previous_value_cell_state< C > | Maintains the state of a previous_value_cell |
| Clive_cells::watcher | Handle for a cell watch function |
| ▼Cstd::exception | |
| Clive_cells::bad_typed_cell_cast | Exception thrown when attempting to cast a cell to a typed_cell with a value type that is incompatible with the cell's value type |
| Clive_cells::stop_compute_exception | Exception indicating that the value of a cell should not be computed |
| Clive_cells::uninitialized_cell_error | Exception indicating that the value of a cell was referenced before its initial value was computed |
| Cstd::hash< live_cells::cell > | |
| Cstd::hash< live_cells::key > | |
| Cstd::hash< live_cells::key_ref > | |
| Cstd::hash< live_cells::maybe< T > > | |
| Cstd::hash< live_cells::typed_cell< T > > | |
| ▼Clive_cells::key | Defines the interface for a key which uniquely identifies a cell |
| Clive_cells::value_key< key_ref, key_ref > | |
| ▼Clive_cells::value_key< key_ref > | |
| Clive_cells::peek_cell_key | Key identifying a peek_cell |
| Clive_cells::constant_key< T > | Key identifying a constant_cell |
| Clive_cells::unique_key | A key of uniquely identified by a single instance |
| Clive_cells::value_key< T, Ts > | Base class for a key distinguished from other keys by one or more values |
| ▼Clive_cells::value_key< T > | Base class for a key distinguished from other keys by one value |
| Clive_cells::previous_value_cell_key< T > | Key identifying a previous_value_cell |
| Clive_cells::store_cell_key< T > | Key identifying a store_cell |
| Clive_cells::key_ref | Dynamically type key container |
| ▼Clive_cells::make_cell< C > | Defines a cell class using C such that the constraints defined by the concept Cell are satisifed |
| Clive_cells::make_mutable_cell< C, Parent > | Same as make_cell but also provides a value setter value(Parent::value_type) so that the definition satisfies the MutableCell concept |
| Clive_cells::maybe< T > | Container holding a cell value or an exception that occurred while computing a value |
| Clive_cells::maybe< value_type > | |
| Clive_cells::merged_observable< T, Ts > | Allows multiple cells to be observed at once |
| Clive_cells::merged_observable< T > | |
| Clive_cells::merged_observable< Ts... > | |
| ▼Clive_cells::observer | Defines the interface for observing changes to the value of a Cell |
| Clive_cells::compute_cell_state< dynamic_compute_state< F > > | |
| Clive_cells::compute_cell_state< store_cell_compute_state< C > > | |
| Clive_cells::mutable_compute_cell_state< std::invoke_result_t< F > > | |
| Clive_cells::compute_cell_state< C > | Cell state for a cell which computes a value as a function of one or more argument cells |
| Clive_cells::mutable_compute_cell_state< T > | Maintains the state of a mutable computed cell |
| Clive_cells::peek_cell_state< C > | Maintains the state of a peek_cell |
| Clive_cells::previous_value_cell_state< C > | Maintains the state of a previous_value_cell |
| ▼Clive_cells::observer_cell_state | Provides functionality for observing a cell from a cell_state |
| Clive_cells::compute_cell_state< dynamic_compute_state< F > > | |
| Clive_cells::compute_cell_state< store_cell_compute_state< C > > | |
| Clive_cells::mutable_compute_cell_state< std::invoke_result_t< F > > | |
| Clive_cells::compute_cell_state< C > | Cell state for a cell which computes a value as a function of one or more argument cells |
| Clive_cells::mutable_compute_cell_state< T > | Maintains the state of a mutable computed cell |
| Clive_cells::previous_value_cell_state< C > | Maintains the state of a previous_value_cell |
| Clive_cells::state_manager | Maintains the association between keys and cell states |
| ▼Clive_cells::stateful_cell< S > | Base class for a cell with a state |
| Clive_cells::dynamic_compute_cell< F, State > | A computed cell which determines its argument cells at runtime |
| Clive_cells::dynamic_mutable_compute_cell< F, R, State > | A mutable computed cell with the argument cells determined dynamically |
| Clive_cells::static_mutable_compute_cell< F, R, State > | A mutable computed cell with arguments determined at compile-time |
| Clive_cells::store_cell< C, State > | A Cell that caches the value of another Cell |
| Clive_cells::stateful_cell< dynamic_compute_cell_state< F > > | |
| Clive_cells::stateful_cell< dynamic_mutable_compute_cell_state< F, R > > | |
| ▼Clive_cells::stateful_cell< mutable_cell_state< T > > | |
| Clive_cells::mutable_cell< T > | A stateful cell which can have its value set directly |
| ▼Clive_cells::stateful_cell< peek_cell_state< C > > | |
| Clive_cells::peek_cell< C > | A Cell that reads the value of another Cell without notifying its observers when it changes |
| ▼Clive_cells::stateful_cell< previous_value_cell_state< C > > | |
| Clive_cells::previous_value_cell< C > | A Cell that evaluates to the previous value of another Cell |
| Clive_cells::stateful_cell< static_mutable_compute_cell_state< F, R > > | |
| Clive_cells::stateful_cell< store_cell_state< C > > | |
| Clive_cells::store_cell_compute_state< C > | Defines the computation function of a store_cell |
| Clive_cells::argument_tracker::tracker< T > | |
| Clive_cells::typed_cell< T > | Dynamically typed Cell container with a static value type |
1.10.0