Struct Kernel

pub struct Kernel<'g, M, S>
where
    M: KernelCallbackObject,
    S: CommitableSubstateStore,
{ /* private fields */ }

Implementations

impl<'g, M, S> Kernel<'g, M, S>

where M: KernelCallbackObject, <M as KernelCallbackObject>::CallFrameData: Default, S: CommitableSubstateStore,

pub fn new_no_refs( store: &'g mut S, id_allocator: &'g mut IdAllocator, callback: &'g mut M, ) -> Kernel<'g, M, S>

impl<'g, M, S> Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

pub fn new( store: &'g mut S, id_allocator: &'g mut IdAllocator, callback: &'g mut M, call_frame_inits: Vec<CallFrameInit<<M as KernelCallbackObject>::CallFrameData>>, ) -> Kernel<'g, M, S>

impl<'g, M, S> Kernel<'g, M, S>

where M: KernelCallbackObject, <M as KernelCallbackObject>::CallFrameData: Default, S: CommitableSubstateStore,

pub fn kernel_create_kernel_for_testing( substate_io: SubstateIO<'g, S>, id_allocator: &'g mut IdAllocator, callback: &'g mut M, always_visible_global_nodes: &'static IndexSet<NodeId>, ) -> Kernel<'g, M, S>

impl<'g, M, S> Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

pub fn kernel_current_frame( &self, ) -> &CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>

pub fn kernel_current_frame_mut( &mut self, ) -> (&SubstateIO<'_, S>, &mut CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>)

pub fn kernel_prev_frame_stack_mut( &mut self, ) -> &mut Vec<CallFrame<<M as KernelCallbackObject>::CallFrameData, <M as KernelCallbackObject>::LockData>>

pub fn kernel_substate_io(&self) -> &SubstateIO<'g, S>

pub fn kernel_substate_io_mut(&mut self) -> &mut SubstateIO<'g, S>

pub fn kernel_id_allocator(&self) -> &IdAllocator

pub fn kernel_id_allocator_mut(&mut self) -> &mut &'g mut IdAllocator

pub fn kernel_callback(&self) -> &M

pub fn kernel_callback_mut(&mut self) -> &mut M

Trait Implementations

impl<'g, M, S> KernelApi for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

type CallbackObject = M

impl<'g, M, S> KernelInternalApi for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

type System = M

fn kernel_get_node_visibility_uncosted( &self, node_id: &NodeId, ) -> NodeVisibility

Returns the visibility of a node.

fn kernel_get_current_stack_depth_uncosted(&self) -> usize

Returns the current stack depth.

fn kernel_get_current_stack_id_uncosted(&self) -> usize

Returns the current stack id.

fn kernel_get_system_state(&mut self) -> SystemState<'_, M>

Returns the system state.

fn kernel_read_substate_uncosted( &self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, ) -> Option<&IndexedScryptoValue>

Returns the value of a substate.

fn kernel_get_system(&mut self) -> &mut Self::System

Returns the system.

impl<'g, M, S> KernelInvokeApi<<M as KernelCallbackObject>::CallFrameData> for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

fn kernel_invoke( &mut self, invocation: Box<KernelInvocation<<M as KernelCallbackObject>::CallFrameData>>, ) -> Result<IndexedScryptoValue, RuntimeError>

impl<'g, M, S> KernelNodeApi for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

fn kernel_pin_node(&mut self, node_id: NodeId) -> Result<(), RuntimeError>

Pin a node to it’s current device.

fn kernel_allocate_node_id( &mut self, entity_type: EntityType, ) -> Result<NodeId, RuntimeError>

Allocates a new node id useable for create_node

fn kernel_create_node( &mut self, node_id: NodeId, node_substates: BTreeMap<PartitionNumber, BTreeMap<SubstateKey, IndexedScryptoValue>>, ) -> Result<(), RuntimeError>

Creates a new RENode

fn kernel_create_node_from( &mut self, node_id: NodeId, partitions: BTreeMap<PartitionNumber, (NodeId, PartitionNumber)>, ) -> Result<(), RuntimeError>

fn kernel_drop_node( &mut self, node_id: &NodeId, ) -> Result<DroppedNode, RuntimeError>

Removes an RENode. Owned children will be possessed by the call frame.

impl<'g, M, S> KernelStackApi for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

type CallFrameData = <M as KernelCallbackObject>::CallFrameData

fn kernel_get_stack_id(&mut self) -> Result<usize, RuntimeError>

Gets the stack id which is currently being used

fn kernel_switch_stack( &mut self, other_stack_index: usize, ) -> Result<(), RuntimeError>

Achieves a context switch by switching the underlying callframe/stack

fn kernel_send_to_stack( &mut self, other_stack_index: usize, value: &IndexedScryptoValue, ) -> Result<(), RuntimeError>

Moves the objects in a scrypto value from the current call frame to another stack

fn kernel_set_call_frame_data( &mut self, data: <M as KernelCallbackObject>::CallFrameData, ) -> Result<(), RuntimeError>

Sets the call frame data for the current call frame

fn kernel_get_owned_nodes(&mut self) -> Result<Vec<NodeId>, RuntimeError>

Returns the owned nodes of the current call frame

impl<'g, M, S> KernelSubstateApi<<M as KernelCallbackObject>::LockData> for Kernel<'g, M, S>

where M: KernelCallbackObject, S: CommitableSubstateStore,

fn kernel_mark_substate_as_transient( &mut self, node_id: NodeId, partition_num: PartitionNumber, key: SubstateKey, ) -> Result<(), RuntimeError>

Marks a substate as transient, or a substate which was never and will never be persisted

fn kernel_open_substate_with_default<F>( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, flags: LockFlags, default: Option<F>, data: <M as KernelCallbackObject>::LockData, ) -> Result<u32, RuntimeError>

where F: FnOnce() -> IndexedScryptoValue,

Locks a substate to make available for reading and/or writing

fn kernel_get_lock_data( &mut self, lock_handle: u32, ) -> Result<<M as KernelCallbackObject>::LockData, RuntimeError>

Retrieves info related to a lock

fn kernel_read_substate( &mut self, lock_handle: u32, ) -> Result<&IndexedScryptoValue, RuntimeError>

Reads the value of the substate locked by the given lock handle

fn kernel_write_substate( &mut self, lock_handle: u32, value: IndexedScryptoValue, ) -> Result<(), RuntimeError>

Writes a value to the substate locked by the given lock handle

fn kernel_close_substate( &mut self, lock_handle: u32, ) -> Result<(), RuntimeError>

Drops the handle on some substate, if the handle is a force write, updates are flushed. No updates should occur if an error is returned.

fn kernel_set_substate( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: SubstateKey, value: IndexedScryptoValue, ) -> Result<(), RuntimeError>

Sets a value to a substate without checking for the original value.

fn kernel_remove_substate( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, ) -> Result<Option<IndexedScryptoValue>, RuntimeError>

Removes a substate from a node and returns the original value.

fn kernel_scan_keys<K>( &mut self, node_id: &NodeId, partition_num: PartitionNumber, limit: u32, ) -> Result<Vec<SubstateKey>, RuntimeError>

where K: SubstateKeyContent,

fn kernel_drain_substates<K>( &mut self, node_id: &NodeId, partition_num: PartitionNumber, limit: u32, ) -> Result<Vec<(SubstateKey, IndexedScryptoValue)>, RuntimeError>

where K: SubstateKeyContent,

fn kernel_scan_sorted_substates( &mut self, node_id: &NodeId, partition_num: PartitionNumber, limit: u32, ) -> Result<Vec<(([u8; 2], Vec<u8>), IndexedScryptoValue)>, RuntimeError>

Reads substates under a node in sorted lexicographical order

fn kernel_open_substate( &mut self, node_id: &NodeId, partition_num: PartitionNumber, substate_key: &SubstateKey, flags: LockFlags, lock_data: L, ) -> Result<u32, RuntimeError>