Struct linera_execution::ApplicationRegistryView

pub struct ApplicationRegistryView<C> {
    pub published_bytecodes: MapView<C, BytecodeId, BytecodeLocation>,
    pub known_applications: MapView<C, UserApplicationId, UserApplicationDescription>,
}

Fields

published_bytecodes: MapView<C, BytecodeId, BytecodeLocation>

The application bytecodes that have been published.

known_applications: MapView<C, UserApplicationId, UserApplicationDescription>

The applications that are known by the chain.

Implementations

impl<C> ApplicationRegistryView<C>

where C: Context + Clone + Send + Sync + 'static, ViewError: From<C::Error>,

pub fn register_published_bytecode( &mut self, id: BytecodeId, location: BytecodeLocation ) -> Result<(), SystemExecutionError>

Registers a published bytecode so that it can be used by applications.

Keeps track of the bytecode’s location so that it can be loaded when needed.

pub async fn bytecode_locations( &self ) -> Result<Vec<(BytecodeId, BytecodeLocation)>, SystemExecutionError>

Returns all the known locations of published bytecode.

pub async fn bytecode_location_for( &self, id: &BytecodeId ) -> Result<Option<BytecodeLocation>, SystemExecutionError>

Returns the location of published bytecode with the given ID.

pub async fn register_application( &mut self, application: UserApplicationDescription ) -> Result<UserApplicationId, SystemExecutionError>

Registers an existing application.

Keeps track of an existing application that the current chain is seeing for the first time.

pub async fn register_new_application( &mut self, application_id: UserApplicationId, parameters: Vec<u8>, required_application_ids: Vec<UserApplicationId> ) -> Result<(), SystemExecutionError>

Registers a newly created application.

pub async fn describe_application( &self, id: UserApplicationId ) -> Result<UserApplicationDescription, SystemExecutionError>

Retrieves an application’s description.

pub async fn find_dependencies( &self, stack: Vec<UserApplicationId>, registered_apps: &HashMap<UserApplicationId, UserApplicationDescription> ) -> Result<Vec<UserApplicationId>, SystemExecutionError>

Retrieves the recursive dependencies of applications and apply a topological sort.

pub async fn describe_applications_with_dependencies( &self, ids: Vec<UserApplicationId>, extra_registered_apps: &HashMap<UserApplicationId, UserApplicationDescription> ) -> Result<Vec<UserApplicationDescription>, SystemExecutionError>

Retrieves applications’ descriptions preceded by their recursive dependencies.

Trait Implementations

impl<C> Debug for ApplicationRegistryView<C>

where MapView<C, BytecodeId, BytecodeLocation>: Debug, MapView<C, UserApplicationId, UserApplicationDescription>: Debug,

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

Formats the value using the given formatter.

impl<C> HashableView<C> for ApplicationRegistryView<C>

where C: Context + Send + Sync + Clone + 'static, ViewError: From<C::Error>,

type Hasher = CoreWrapper<Sha3_256Core>

How to compute hashes.

fn hash_mut<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<<Self::Hasher as Hasher>::Output, ViewError>> + Send + 'async_trait>>

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

Computes the hash of the values.

fn hash<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<<Self::Hasher as Hasher>::Output, ViewError>> + Send + 'async_trait>>

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

Computes the hash of the values.

impl<C> View<C> for ApplicationRegistryView<C>

where C: Context + Send + Sync + Clone + 'static, ViewError: From<C::Error>,

fn context(&self) -> &C

Obtains a mutable reference to the internal context.

fn load<'async_trait>( context: C ) -> Pin<Box<dyn Future<Output = Result<Self, ViewError>> + Send + 'async_trait>>

where Self: 'async_trait,

Creates a view or a subview.

fn rollback(&mut self)

Discards all pending changes. After that flush should have no effect to storage.

fn flush(&mut self, batch: &mut Batch) -> Result<(), ViewError>

Persists changes to storage. This leaves the view still usable and is essentially neutral to the program running. Crash-resistant storage implementations are expected to accumulate the desired changes in the batch variable first. If the view is dropped without calling flush, staged changes are simply lost.

fn clear(&mut self)

Clears the view. That can be seen as resetting to default. If the clear is followed by a flush then all the relevant data is removed on the storage.