Struct Input

pub struct Input<T>(/* private fields */);

Helper to define a Computation for a simple input type which has no fields and thus does not require a HashMap to cache each possible value. To use in a Computation, T must implement OutputTypeForInput to specify its output type. T cannot provide a run function since it cannot have any dependencies as an input. Its value must be manually set via Db::update_input(db, input, value)

Examples include struct SourceFile; or struct Time;

Implementations

impl<T> Input<T>

pub const fn new() -> Self

Trait Implementations

impl<T: Clone> Clone for Input<T>

fn clone(&self) -> Input<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: OutputTypeForInput + 'static> Computation for Input<T>

type Output = <T as OutputTypeForInput>::Output

type Storage = (Option<Cell>, Option<<Input<T> as Computation>::Output>)

fn run(&self, _: &mut DbHandle<'_, impl Computation>) -> Self::Output

fn input_to_cell(_: &Self, storage: &Self::Storage) -> Option<Cell>

fn get_function_and_output( _: Cell, storage: &Self::Storage, ) -> (&Self, Option<&Self::Output>)

fn set_output(_: Cell, new_output: Self::Output, storage: &mut Self::Storage)

fn insert_new_cell(cell: Cell, _: Self, storage: &mut Self::Storage)

fn computation_id_of<T: Computation>() -> u32

fn get_storage<Concrete: Computation + 'static>( computation_id: u32, container: &Self::Storage, ) -> &Concrete::Storage

fn get_storage_mut<Concrete: Computation + 'static>( computation_id: u32, container: &mut Self::Storage, ) -> &mut Concrete::Storage

fn output_is_unset<FullComputation: Computation>( cell: Cell, computation_id: u32, original_computation_id: u32, db: &Db<FullComputation>, ) -> bool

True if this has any cached output

fn dispatch_run<FullComputation: Computation>( cell: Cell, computation_id: u32, original_computation_id: u32, db: &mut Db<FullComputation>, ) -> bool

where Self: Clone, Self::Output: Eq,

Given a Cell, TypeId pair dispatch to the correct run function and return true if the value has changed. This should also cache the new value if it has changed. Note that in dispatch functions Self is always the concrete, non-tuple type.

fn dispatch_update_output<Concrete, FullComputation>( cell: Cell, computation_id: u32, original_computation_id: u32, output: Concrete::Output, db: &mut Db<FullComputation>, ) -> bool

where Concrete: Computation, FullComputation: Computation, Self::Output: Eq,

Dispatch to the correct update_output function to cache the new output and return true if the value has changed. Note that in dispatch functions Self is the current type being dispatched, Concrete, if present, is the non-tuple type of the target computation, and FullComputation is the type of the Db computation parameter which is usually a tuple of every possible computation.

fn dispatch_input_to_cell<Concrete>( input: &Concrete, container: &Self::Storage, ) -> Option<Cell>

where Concrete: 'static + Computation + Any,

fn dispatch_insert_new_cell<Concrete>( cell: Cell, input: Concrete, storage: &mut Self::Storage, )

where Concrete: 'static + Computation + Any, Concrete::Storage: 'static,

impl<T: Debug> Debug for Input<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.