Struct Provider 

pub struct Provider<E, V> { /* private fields */ }

Key-value container of a V value for every possible E.

Implementations

impl<E, V> Provider<E, V>

where E: BlockModule,

pub async fn new<F>( progress: YieldProgress, definer: F, ) -> Result<Self, GenError>

where F: FnMut(E) -> Result<V, InGenError>,

Constructs a Provider with values computed by the given function.

This is an async function for the sake of cancellation and optional cooperative multitasking. It may be blocked on from a synchronous context (but if that is the only use, consider calling Provider::new_sync() instead).

impl<E: BlockModule> Provider<E, Block>

pub async fn new_installed_cyclic<F>( progress: YieldProgress, txn: &mut UniverseTransaction, definer: F, ) -> Result<Self, GenError>

where F: FnMut(&Provider<E, Block>, &mut UniverseTransaction, E) -> Result<Block, InGenError>,

Constructs a BlockProvider with BlockDefs whose block values are computed by the given function.

The module itself is passed to definer, which may be used to create relationships among the blocks (e.g. one having the behavior of turning into another). Attempting to read those handles will necessarily fail.

pub fn install( &self, read_ticket: ReadTicket<'_>, txn: &mut UniverseTransaction, ) -> Result<Self, InsertError>

Add the block definitions stored in this BlockProvider into universe as BlockDefs, returning a new BlockProvider whose blocks refer to those definitions (via Primitive::Indirect).

The given read_ticket should be sufficient for evaluating the blocks in self.

pub fn using(universe: &Universe) -> Result<Self, ProviderError>

where E: Eq + Hash + Display,

Obtain the definitions of E’s blocks from universe, returning a new BlockProvider whose blocks refer to those definitions (via Primitive::Indirect).

Returns an error if any of the blocks are not defined in that universe.

impl<E: Exhaust + Debug + Clone + Eq + Hash, V> Provider<E, V>

These methods do not require E to be a BlockModule.

pub fn new_sync<F>(definer: F) -> Self

where F: FnMut(E) -> V,

Alternative to Self::new() which is neither async nor fallible.

pub fn subset<K>(&self, function: impl Fn(K) -> E) -> Provider<K, V>

where K: Exhaust + Debug + Clone + Eq + Hash, V: Clone,

Create another Provider with different keys that map into a subset of this provider’s keys.

TODO: add a test

pub fn map<V2>(&self, function: impl FnMut(&E, &V) -> V2) -> Provider<E, V2>

Create another Provider with a modification to each value.

pub fn iter(&self) -> ModuleIter<'_, E, V>

Iterate over the entire contents of this.

Trait Implementations

impl<E: Clone, V: Clone> Clone for Provider<E, V>

fn clone(&self) -> Provider<E, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug, V: Debug> Debug for Provider<E, V>

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

Formats the value using the given formatter.

impl<E, V> Default for Provider<E, V>

where E: DefaultProvision<V> + Exhaust + Eq + Hash + Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<E: Eq + Hash, V> Index<&E> for Provider<E, V>

type Output = V

The returned type after indexing.

fn index(&self, index: &E) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E: Eq + Hash, V> Index<E> for Provider<E, V>

type Output = V

The returned type after indexing.

fn index(&self, index: E) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'provider, E: Exhaust + Debug + Clone + Eq + Hash, V> IntoIterator for &'provider Provider<E, V>

type Item = (E, &'provider V)

The type of the elements being iterated over.

type IntoIter = ModuleIter<'provider, E, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<E: Eq + Hash, V: PartialEq> PartialEq for Provider<E, V>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: Eq + Hash + VisitHandles, V: VisitHandles> VisitHandles for Provider<E, V>

fn visit_handles(&self, visitor: &mut dyn HandleVisitor)

For each Handle contained within self that is reachable without traversing another Handle, call visitor with a reference to it.

impl<E: Eq + Hash, V: PartialEq> Eq for Provider<E, V>