Struct TypedState

pub struct TypedState<K, V, T, D> {
    pub(crate) state: State<T>,
    pub(crate) _phantom: PhantomData<fn() -> (K, V, D)>,
}

A newtype wrapper of State that guarantees the K, V, and D codecs match the ones in durable storage.

Fields

state: State<T>

_phantom: PhantomData<fn() -> (K, V, D)>

Implementations

impl<K, V, T: Clone, D> TypedState<K, V, T, D>

pub(crate) fn clone(&self, applier_version: Version, hostname: String) -> Self

pub(crate) fn clone_for_rollup(&self) -> Self

impl<K, V, T, D> TypedState<K, V, T, D>

where K: Codec, V: Codec, T: Timestamp + Lattice + Codec64, D: Codec64,

pub fn new( applier_version: Version, shard_id: ShardId, hostname: String, walltime_ms: u64, ) -> Self

pub fn clone_apply<R, E, WorkFn>( &self, cfg: &PersistConfig, work_fn: &mut WorkFn, ) -> ControlFlow<E, (R, Self)>

where WorkFn: FnMut(SeqNo, &PersistConfig, &mut StateCollections<T>) -> ControlFlow<E, R>,

Methods from Deref<Target = State<T>>

pub fn shard_id(&self) -> ShardId

pub fn seqno(&self) -> SeqNo

pub fn since(&self) -> &Antichain<T>

pub fn upper(&self) -> &Antichain<T>

pub fn spine_batch_count(&self) -> usize

pub fn size_metrics(&self) -> StateSizeMetrics

pub fn latest_rollup(&self) -> (&SeqNo, &HollowRollup)

pub(crate) fn seqno_since(&self) -> SeqNo

pub fn maybe_gc( &mut self, is_write: bool, now: u64, cfg: GcConfig, ) -> Option<GcReq>

pub fn seqnos_held(&self) -> usize

Return the number of gc-ineligible state versions.

pub fn expire_at(&mut self, walltime_ms: EpochMillis) -> ExpiryMetrics

Expire all readers and writers up to the given walltime_ms.

pub fn snapshot( &self, as_of: &Antichain<T>, ) -> Result<Vec<HollowBatch<T>>, SnapshotErr<T>>

Returns the batches that contain updates up to (and including) the given as_of. The result Vec contains blob keys, along with a Description of what updates in the referenced parts are valid to read.

pub fn verify_listen( &self, as_of: &Antichain<T>, ) -> Result<Result<(), Upper<T>>, Since<T>>

pub fn next_listen_batch( &self, frontier: &Antichain<T>, ) -> Result<HollowBatch<T>, SeqNo>

pub fn active_rollup(&self) -> Option<ActiveRollup>

pub fn need_rollup( &self, threshold: usize, use_active_rollup: bool, fallback_threshold_ms: u64, now: u64, ) -> Option<SeqNo>

pub(crate) fn blobs(&self) -> impl Iterator<Item = HollowBlobRef<'_, T>>

pub fn apply_encoded_diffs<'a, I: IntoIterator<Item = &'a VersionedData>>( &mut self, cfg: &PersistConfig, metrics: &Metrics, diffs: I, )

pub fn apply_diffs<I: IntoIterator<Item = (StateDiff<T>, Bytes)>>( &mut self, metrics: &Metrics, diffs: I, )

pub(super) fn apply_diff( &mut self, metrics: &Metrics, diff: StateDiff<T>, ) -> Result<(), String>

Trait Implementations

impl<K, V, T: Debug, D> Debug for TypedState<K, V, T, D>

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

Formats the value using the given formatter.

impl<K, V, T, D> Deref for TypedState<K, V, T, D>

type Target = State<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<K, V, T, D> DerefMut for TypedState<K, V, T, D>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<K, V, T, D> From<TypedState<K, V, T, D>> for UntypedState<T>

where K: Codec, V: Codec, T: Codec64, D: Codec64,

fn from(typed_state: TypedState<K, V, T, D>) -> Self

Converts to this type from the input type.

impl<K, V, T: PartialEq, D> PartialEq for TypedState<K, V, T, D>

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

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

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

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