Enum BlobReader 

pub enum BlobReader<CS> {
    SingleChunk {
        cursor: Cursor<Chunk>,
    },
    ChunkedBlob {
        blob_meta: BlobMeta,
        chunk_store: CS,
        fetch_concurrency: usize,
        pos: u64,
        current_chunk: Cursor<Chunk>,
        stream: BoxStream<'static, Result<Cursor<Chunk>>>,
    },
}

A reader for one Blob.

Supports single-chunked blobs as well as blobs composed of multiple chunks.

In the latter case, it takes an existing BlobMeta with a specific chunking provided upfront.

Any fallback to other chunkings, needs to be happen elsewhere.

Variants

SingleChunk

Blob is composed of a single chunk. This allows skipping asking for a BlobMeta. For very small blobs the callsite might ask a ChunkStore directly.

Fields

cursor: Cursor<Chunk>

ChunkedBlob

The blob is composed of multiple chunks, and we need to query a ChunkStore to read data.

Fields

blob_meta: BlobMeta

chunk_store: CS

fetch_concurrency: usize

pos: u64

current_chunk: Cursor<Chunk>

stream: BoxStream<'static, Result<Cursor<Chunk>>>

Implementations

impl<CS> BlobReader<CS>

where CS: ChunkStore + Clone + 'static,

pub fn from_single_chunk(chunk: Chunk) -> Self

Initialize a BlobReader with the Chunk of a single-chunked blob

pub fn from_blob_meta( blob_meta: BlobMeta, chunk_store: CS, fetch_concurrency: usize, ) -> BlobReader<CS>

Initialize a BlobReader with a fixed BlobMeta, a reference to a ChunkStore and a fetch concurrency.

fn blob_len(&self) -> u64

The total length of the blob. Length of the single chunk or, for chunked blobs, the length as specified in the BlobMeta.

fn position(&self) -> u64

Get the current position, from the start of the blob.

Trait Implementations

impl<CS> AsyncBufRead for BlobReader<CS>

where CS: ChunkStore,

fn poll_fill_buf( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<&[u8]>>

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<CS> AsyncRead for BlobReader<CS>

where CS: ChunkStore,

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl<CS> AsyncSeek for BlobReader<CS>

where CS: ChunkStore + Clone + 'static,

fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> Result<()>

Attempts to seek to an offset, in bytes, in a stream.

fn poll_complete( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<u64>>

Waits for a seek operation to complete.

impl<CS> LimitBlobReader for BlobReader<CS>

where CS: ChunkStore + Clone + 'static,

fn copy_limited( &self, offset: u64, size: u64, w: &mut dyn Write, ) -> impl Future<Output = Result<u64>>

Copies up to size bytes starting from offset into the passed writer.

impl<CS> Reader for BlobReader<CS>

where CS: ChunkStore + Clone + 'static,

impl<'__pin, CS> Unpin for BlobReader<CS>

where PinnedFieldsOf<__Origin<'__pin, CS>>: Unpin,