Struct BlockChain

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

A Chain which stores every mutation of its subject in a series of ChainBlocks

Implementations

impl<State, Txn, FE, T> BlockChain<State, Txn, FE, T>

pub fn history(&self) -> &History<State, Txn, FE>

Trait Implementations

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

where State: StateInstance, State::FE: AsType<ChainBlock> + for<'a> FileSave<'a>, T: 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 BlockChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: CacheBlock + for<'a> FileSave<'a>, T: 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 BlockChain<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, BlockChain<State, <State as StateInstance>::Txn, <State as StateInstance>::FE, T>> for BlockChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: CacheBlock + for<'a> FileSave<'a>, T: Route<State> + Persist<State::FE, Txn = State::Txn> + 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 BlockChain<State, Txn, FE, T>

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

Formats the value using the given formatter.

impl<State, Txn, FE, T> From<BlockChain<State, Txn, FE, T>> for Chain<State, Txn, FE, T>

fn from(chain: BlockChain<State, Txn, FE, T>) -> Self

Converts to this type from the input type.

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

where State: StateInstance + FromStream<Context = State::Txn> + From<Collection<State::Txn, State::FE>> + From<Scalar>, State::FE: CacheBlock + for<'a> FileSave<'a>, T: Route<State> + FromStream<Context = State::Txn> + Debug, (Bytes, Map<Tuple<State>>): TryCastFrom<State>, Collection<State::Txn, State::FE>: TryCastFrom<State>, Scalar: TryCastFrom<State>, Value: TryCastFrom<State>, (Value,): TryCastFrom<State>, (Value, State): TryCastFrom<State>,

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: State::Txn, 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 BlockChain<State, State::Txn, State::FE, T>

where State: StateInstance, State::FE: CacheBlock + for<'a> FileSave<'a>, 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, SeqStream<Result<(Bytes, MapStream<TxnId, Result<SeqStream<Result<MutationView<'en>, TCError>, Pin<Box<dyn Stream<Item = Result<MutationView<'en>, TCError>> + Send + Unpin + 'en>>>, TCError>, Pin<Box<dyn Stream<Item = (TxnId, Result<SeqStream<Result<MutationView<'en>, TCError>, Pin<Box<dyn Stream<Item = Result<MutationView<'en>, TCError>> + Send + Unpin + 'en>>>, TCError>)> + Send + Unpin + 'en>>>), TCError>, Pin<Box<dyn Stream<Item = Result<(Bytes, MapStream<TxnId, Result<SeqStream<Result<MutationView<'en>, TCError>, Pin<Box<dyn Stream<Item = Result<MutationView<'en>, TCError>> + Send + Unpin + 'en>>>, TCError>, Pin<Box<dyn Stream<Item = (TxnId, Result<SeqStream<Result<MutationView<'en>, TCError>, Pin<Box<dyn Stream<Item = Result<MutationView<'en>, TCError>> + Send + Unpin + 'en>>>, TCError>)> + Send + Unpin + 'en>>>), TCError>> + Send + Unpin + 'en>>>)

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 BlockChain<State, State::Txn, State::FE, T>

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

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 BlockChain<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, 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> Replicate<<State as StateInstance>::Txn> for BlockChain<State, State::Txn, State::FE, CollectionBase<State::Txn, State::FE>>

where State: StateInstance + From<Collection<State::Txn, State::FE>> + From<Scalar>, State::FE: CacheBlock, Collection<State::Txn, State::FE>: TryCastFrom<State>, CollectionBase<State::Txn, State::FE>: Route<State>, Scalar: TryCastFrom<State>, 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> Route<State> for BlockChain<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> + Clone + Debug, Collection<State::Txn, State::FE>: TryCastFrom<State>, Scalar: TryCastFrom<State>,

fn route<'a>( &'a self, path: &'a [PathSegment], ) -> Option<Box<dyn Handler<'a, State> + 'a>>

impl<State, T> Transact for BlockChain<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.