Struct SyncChain

pub struct SyncChain<State, Txn, FE, T> { /* private fields */ }

A super::Chain which keeps only the data needed to recover the state of its subject in the event of a transaction failure.

Implementations

impl<State, T> SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: AsType<ChainBlock>, T: Persist<State::FE, Txn = State::Txn> + Restore<State::FE> + TryCastFrom<State>, Self: TryCastFrom<State>,

pub async fn restore_from( &self, txn: &State::Txn, source: Link, attr: Id, ) -> TCResult<()>

Trait Implementations

impl<State, T> AsyncHash for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, T: AsyncHash + Send + Sync,

fn hash<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, ) -> Pin<Box<dyn Future<Output = TCResult<Output<Sha256>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Compute the hash of this state as of a given TxnId

impl<State, T> ChainInstance<State, T> for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: CacheBlock, T: Persist<State::FE, Txn = State::Txn> + Route<State> + Debug, Collection<State::Txn, State::FE>: TryCastFrom<State>, Scalar: TryCastFrom<State>,

fn append_delete(&self, txn_id: TxnId, key: Value) -> TCResult<()>

Append the given DELETE op to the latest block in this Chain.

fn append_put(&self, txn: State::Txn, key: Value, value: State) -> TCResult<()>

Append the given PUT op to the latest block in this Chain.

fn subject(&self) -> &T

Borrow the subject of this Chain.

impl<State, Txn, FE, T> Clone for SyncChain<State, Txn, FE, T>

where T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<State, T> CopyFrom<<State as StateInstance>::FE, SyncChain<State, <State as StateInstance>::Txn, <State as StateInstance>::FE, T>> for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: CacheBlock + for<'a> FileSave<'a>, T: Persist<State::FE, Txn = State::Txn> + Route<State> + Debug,

fn copy_from<'life0, 'async_trait>( _txn: &'life0 State::Txn, _store: Dir<State::FE>, _instance: Self, ) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Copy a new instance of Self from an existing instance.

impl<State, Txn, FE, T> Debug for SyncChain<State, Txn, FE, T>

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

Formats the value using the given formatter.

impl<State, T> FromStream for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: CacheBlock + for<'a> FileSave<'a>, T: FromStream<Context = State::Txn>,

type Context = <State as StateInstance>::Txn

The decoding context of this type, useful in situations where the stream to be decoded may be too large to hold in main memory.

fn from_stream<'life0, 'async_trait, D>( txn: Self::Context, decoder: &'life0 mut D, ) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>>

where D: 'async_trait + Decoder, Self: 'async_trait, 'life0: 'async_trait,

Parse this value using the given Decoder.

impl<'en, State, T> IntoView<'en, <State as StateInstance>::FE> for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, T: IntoView<'en, State::FE, Txn = State::Txn> + Send + Sync,

type Txn = <State as StateInstance>::Txn

The type of Transaction which this state supports

type View = <T as IntoView<'en, <State as StateInstance>::FE>>::View

The type of encodable view returned by into_view

fn into_view<'async_trait>( self, txn: Self::Txn, ) -> Pin<Box<dyn Future<Output = TCResult<Self::View>> + Send + 'async_trait>>

where Self: 'async_trait,

Return a View which can be encoded with en::IntoStream.

impl<State, T> Persist<<State as StateInstance>::FE> for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: CacheBlock + for<'a> FileSave<'a>, T: Persist<State::FE, Txn = State::Txn> + Send + Sync,

type Txn = <State as StateInstance>::Txn

type Schema = <T as Persist<<State as StateInstance>::FE>>::Schema

fn create<'async_trait>( txn_id: TxnId, schema: Self::Schema, store: Dir<State::FE>, ) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>

where Self: 'async_trait,

Create a new instance of Self from an empty Store.

fn load<'async_trait>( txn_id: TxnId, schema: Self::Schema, store: Dir<State::FE>, ) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>

where Self: 'async_trait,

Load a saved instance of Self from persistent storage. Should only be invoked at startup time.

fn dir(&self) -> Inner<State::FE>

Access the filesystem directory backing this persistent data structure.

fn load_or_create<'async_trait>( txn_id: TxnId, schema: Self::Schema, store: Dir<FE>, ) -> Pin<Box<dyn Future<Output = Result<Self, TCError>> + Send + 'async_trait>>

where Self: Send + 'async_trait,

Load a saved instance of Self from persistent storage if present, or create a new one.

impl<State, T> Recover<<State as StateInstance>::FE> for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance + From<Collection<State::Txn, State::FE>> + From<Scalar>, State::FE: CacheBlock + for<'a> FileSave<'a>, T: Route<State> + Debug + Send + Sync, Collection<State::Txn, State::FE>: TryCastFrom<State>, Scalar: TryCastFrom<State>,

type Txn = <State as StateInstance>::Txn

fn recover<'life0, 'life1, 'async_trait>( &'life0 self, txn: &'life1 State::Txn, ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Recover this state after loading, in case the last transaction failed or was interrupted.

impl<State, T> Replicate<<State as StateInstance>::Txn> for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: AsType<ChainBlock>, T: Persist<State::FE, Txn = State::Txn> + Restore<State::FE> + TryCastFrom<State> + AsyncHash + Send + Sync, Self: TryCastFrom<State>,

fn replicate<'life0, 'life1, 'async_trait>( &'life0 self, txn: &'life1 State::Txn, source: Link, ) -> Pin<Box<dyn Future<Output = TCResult<Output<Sha256>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update the state of this replica from the given source.

impl<State, T> Transact for SyncChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: AsType<ChainBlock> + for<'a> FileSave<'a>, T: Transact + Send + Sync,

type Commit = <T as Transact>::Commit

A guard which blocks concurrent commits

fn commit<'life0, 'async_trait>( &'life0 self, txn_id: TxnId, ) -> Pin<Box<dyn Future<Output = Self::Commit> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Commit this transaction.

fn rollback<'life0, 'life1, 'async_trait>( &'life0 self, txn_id: &'life1 TxnId, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Roll back this transaction.

fn finalize<'life0, 'life1, 'async_trait>( &'life0 self, txn_id: &'life1 TxnId, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete any version data specific to this transaction.