Enum Chain

pub enum Chain<State, Txn, FE, T> {
    Block(BlockChain<State, Txn, FE, T>),
    Sync(SyncChain<State, Txn, FE, T>),
}

A data structure responsible for maintaining the integrity of a mutable subject.

Variants

Block(BlockChain<State, Txn, FE, T>)

Sync(SyncChain<State, Txn, FE, T>)

Trait Implementations

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

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

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

where State: Send + Sync, Txn: Send + Sync, FE: Send + Sync, T: Send + Sync,

type Class = ChainType

The Class type of this instance

fn class(&self) -> Self::Class

Returns the [Class] of this instance.

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

where State: StateInstance, T: IntoView<'en, State::FE, Txn = State::Txn> + Send + Sync + 'en, BlockChain<State, State::Txn, State::FE, T>: IntoView<'en, State::FE, View = (T::View, SeqStream<TCResult<(Bytes, MapStream<TxnId, TCResult<SeqStream<TCResult<MutationView<'en>>, TCBoxTryStream<'en, MutationView<'en>>>>, TCBoxStream<'en, (TxnId, TCResult<SeqStream<TCResult<MutationView<'en>>, TCBoxTryStream<'en, MutationView<'en>>>>)>>)>, TCBoxTryStream<'en, (Bytes, MapStream<TxnId, TCResult<SeqStream<TCResult<MutationView<'en>>, TCBoxTryStream<'en, MutationView<'en>>>>, TCBoxStream<'en, (TxnId, TCResult<SeqStream<TCResult<MutationView<'en>>, TCBoxTryStream<'en, MutationView<'en>>>>)>>)>>), Txn = State::Txn> + Send + Sync, SyncChain<State, State::Txn, State::FE, T>: IntoView<'en, State::FE, View = T::View, Txn = State::Txn> + Send + Sync,

type Txn = <State as StateInstance>::Txn

The type of Transaction which this state supports

type View = ChainView<'en, <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 Chain<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,

type Txn = <State as StateInstance>::Txn

type Schema = (ChainType, <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 Chain<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> Replicate<<State as StateInstance>::Txn> for Chain<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> + TryCastFrom<State>, Scalar: TryCastFrom<State>, BlockChain<State, State::Txn, State::FE, CollectionBase<State::Txn, State::FE>>: TryCastFrom<State>, SyncChain<State, State::Txn, State::FE, CollectionBase<State::Txn, State::FE>>: 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 Chain<State, State::Txn, State::FE, T>

where State: StateInstance, T: Persist<State::FE, Txn = State::Txn> + Route<State> + Clone + Debug, Self: ChainInstance<State, T>,

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

impl<State, T> Transact for Chain<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> + Transact + Debug,

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.