Struct MultiResourceReader 

pub struct MultiResourceReader<I, O: MultiResourceReaderOpener<I>> { /* private fields */ }

Reads an ordered set of physical resources as one logical, restartable input.

Contract

• Input/output: I, same as every delegate the opener produces.
• State/checkpoint: ResourceSetRevision plus the current resource’s ordinal and embedded delegate position, through the paired MultiResourceReaderStream. A resource-set revision mismatch on restart fails closed rather than reinterpreting a stored index against a different physical resource.
• Ordering: resources are traversed in ResourceSet’s declared order; within a resource, delegate order is preserved.
• Restartability: the meet of this wrapper’s own (always restartable, since the durable envelope is self-contained) and the opener’s declared restartability, supplied explicitly at construction (multi_resource_reader’s restartability parameter) because a resource backend’s stable-identity guarantee (e.g. an object store without version tokens) cannot be introspected from here.
• Thread safety: used exclusively (&mut self) like every reader; internally synchronized with its paired stream via an async-aware lock, since the stream (&self) must observe the same active resource’s position at a commit boundary.
• Bounded resource: at most one resource’s delegate open at a time; the current resource’s delegate stream is always closed (with crate::StreamRuntimeOutcome::ResourceBoundary) before the next resource is opened, never overlapping.
• Close: a resource exhausted mid-attempt is closed immediately, right there, rather than held open until the outer step attempt ends; the paired MultiResourceReaderStream::close closes whichever resource (if any) is still active when the step attempt reaches its own terminal outcome, and never re-closes a resource already closed at a boundary.
• Support tier: first-party.

Trait Implementations

impl<I, O> ItemReader<I> for MultiResourceReader<I, O>

where I: Send + 'static, O: MultiResourceReaderOpener<I> + 'static,

async fn read( &mut self, context: ReadContext<'_>, ) -> Result<ReadOutcome<I>, ReaderError>

Reads at most one item while borrowing the reader and call scope.