Struct ClientState 

pub struct ClientState<E, SP> { /* private fields */ }

Keeps track of client graph state.

• E should be an implementation of Engine.
• SP should be an implementation of StorageProvider.

Implementations

impl<E, SP> ClientState<E, SP>

pub const fn new(engine: E, provider: SP) -> Self

Creates a ClientState.

pub fn provider(&mut self) -> &mut SP

Provide access to the StorageProvider.

impl<E, SP> ClientState<E, SP>

where E: Engine, SP: StorageProvider,

pub fn new_graph( &mut self, policy_data: &[u8], action: <E::Policy as Policy>::Action<'_>, sink: &mut impl Sink<E::Effect>, ) -> Result<GraphId, ClientError>

Create a new graph (AKA Team). This graph will start with the initial policy provided which must be compatible with the engine E. The payload is the initial init message that will bootstrap the graph facts. Effects produced when processing the payload are emitted to the sink.

pub fn remove_graph(&mut self, graph_id: GraphId) -> Result<(), ClientError>

Remove a graph (AKA Team). The graph commands will be removed from storage.

pub fn commit( &mut self, trx: &mut Transaction<SP, E>, sink: &mut impl Sink<E::Effect>, ) -> Result<(), ClientError>

Commit the Transaction to storage, after merging all temporary heads.

pub fn add_commands( &mut self, trx: &mut Transaction<SP, E>, sink: &mut impl Sink<E::Effect>, commands: &[impl Command], ) -> Result<usize, ClientError>

Add commands to the transaction, writing the results to sink. Returns the number of commands that were added.

pub fn update_heads( &mut self, storage_id: GraphId, addrs: impl IntoIterator<Item = Address>, request_heads: &mut PeerCache, ) -> Result<(), ClientError>

pub fn head_address( &mut self, storage_id: GraphId, ) -> Result<Address, ClientError>

Returns the address of the head of the graph.

pub fn action( &mut self, storage_id: GraphId, sink: &mut impl Sink<E::Effect>, action: <E::Policy as Policy>::Action<'_>, ) -> Result<(), ClientError>

Performs an action, writing the results to sink.

impl<E, SP> ClientState<E, SP>

where SP: StorageProvider,

pub fn transaction(&mut self, storage_id: GraphId) -> Transaction<SP, E>

Create a new Transaction, used to receive Commands when syncing.

pub fn session( &mut self, storage_id: GraphId, ) -> Result<Session<SP, E>, ClientError>

Create an ephemeral Session associated with this client.

pub fn command_exists(&mut self, storage_id: GraphId, address: Address) -> bool

Checks if a command with the given address exists in the specified graph.

Returns true if the command exists, false if it doesn’t exist or the graph doesn’t exist. This method is used to determine if we need to sync when a hello message is received.

Trait Implementations

impl<E: Debug, SP: Debug> Debug for ClientState<E, SP>

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

Formats the value using the given formatter.