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 delete(self, batch: &mut Batch)

Instead of persisting changes, clears all the data that belong to this view and its subviews. Crash-resistant storage implementations are expected to accumulate the desired changes into the batch variable first. No data/metadata at all is left after deletion. The view is consumed by delete.

fn clear(&mut self)

Clears the view. That can be seen as resetting to default. In the case of a RegisterView this means setting the value to T::default(). For LogView, QueueView, this leaves the range data to be left in the database.