Struct IncomingResources 

pub struct IncomingResources<C>
where
    C: ResourceTable<IncomingResourceState>,
{ /* private fields */ }

Implementations

impl<C> IncomingResources<C>

where C: ResourceTable<IncomingResourceState>,

pub fn accept( &mut self, link_id: LinkId, offer: AcceptedResource<'_>, ) -> Result<usize, AcceptIncomingResourceError>

The capacity and shape gate the engine asks at accept; policy gating happens before the offer ever reaches the table. The duplicate refusal is RNS 1.4.2 Resource.accept’s has_incoming_resource registration gate.

pub fn apply_hashmap_update( &mut self, index: usize, segment: u64, names: &[u8], ) -> Result<usize, ApplyHashmapUpdateError>

RNS 1.4.2 Resource.hashmap_update. We refuse two shapes the reference mishandles:

• Names past the part count: an IndexError off its fixed-length [None] * total_parts list, uncaught until the delivering interface’s read loop, which tears the whole interface down.
• A segment that skips ahead of the height: lands silently while hashmap_height (a fill count, not a prefix height) inflates, so request_next reads None holes.

As the receiver we drive the requests, so a hole can only come from a sender we should not trust.

pub fn place_part( &mut self, index: usize, at_part_index: usize, bytes: &[u8], ) -> PlacePartOutcome

RNS 1.4.2 Resource.receive_part’s bookkeeping half. A part before the last must fill the sdu exactly: parts land at index × sdu, so a short middle part could only corrupt.

pub fn lookup(&self, link_id: &LinkId, hash: &ResourceHash) -> Option<usize>

pub fn state(&self, index: usize) -> &IncomingResourceState

pub fn state_mut(&mut self, index: usize) -> &mut IncomingResourceState

pub fn sealed_transfer(&self, index: usize) -> &[u8]

Never payload bytes: once complete, the transfer opens in place and the plaintext emerges as a sub-slice.

pub fn transfer_and_streamed_open_mut( &mut self, index: usize, ) -> (&mut [u8], &mut OpenProgress)

The sealed transfer and its streamed-open slot, borrowed together: the frontier advance and the conclusion walk them in lockstep. Never payload bytes: the transfer opens in place and the plaintext emerges as a sub-slice.

pub fn transfer_and_streamed_open(&self, index: usize) -> (&[u8], &OpenProgress)

The read-only pair for the offload’s owed-span scan and job view.

pub fn link_at(&self, index: usize) -> &LinkId

pub fn hash_at(&self, index: usize) -> &ResourceHash

pub fn received_flags(&self, index: usize) -> &[bool]

pub fn names_flat(&self, index: usize) -> &[u8]

pub fn remove(&mut self, link_id: &LinkId, hash: &ResourceHash) -> RemoveOutcome

pub fn set_timeout_at( &mut self, index: usize, timeout_at: Option<InstantMillis>, )

pub fn earliest_timeout_at(&self) -> Option<InstantMillis>

pub fn due_index(&self, now: InstantMillis) -> Option<usize>

pub fn transfer_capacity(&self) -> usize

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl<C> Debug for IncomingResources<C>

where C: Debug + ResourceTable<IncomingResourceState>,

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

Formats the value using the given formatter.

impl<C> Default for IncomingResources<C>

where C: Default + ResourceTable<IncomingResourceState>,

fn default() -> IncomingResources<C>

Returns the “default value” for a type.