Skip to main content

InfiniteReader

Struct InfiniteReader

pub struct InfiniteReader { /* private fields */ }

Expand description

A(n) (in)finite random byte stream implementing AsyncRead.

Cheap to serve, expensive to download. Eat while it’s hot my dear little bots.

Implementations§

impl InfiniteReader

pub fn new() -> InfiniteReader

Create an new default InfiniteReader.

pub fn maybe_with_throttle(self, delay: Option<Duration>) -> InfiniteReader

Define the max throttle to be used for the intervals.

Setting it will ensure that we have randomised throttles between reads, making it more effective.

pub fn maybe_set_throttle( &mut self, delay: Option<Duration>, ) -> &mut InfiniteReader

Define the max throttle to be used for the intervals.

Setting it will ensure that we have randomised throttles between reads, making it more effective.

pub fn with_throttle(self, delay: Duration) -> InfiniteReader

Define the max throttle to be used for the intervals.

Setting it will ensure that we have randomised throttles between reads, making it more effective.

pub fn set_throttle(&mut self, delay: Duration) -> &mut InfiniteReader

Define the max throttle to be used for the intervals.

Setting it will ensure that we have randomised throttles between reads, making it more effective.

pub fn without_throttle(self) -> InfiniteReader

Define the max throttle to be used for the intervals.

Setting it will ensure that we have randomised throttles between reads, making it more effective.

pub fn unset_throttle(&mut self) -> &mut InfiniteReader

Define the max throttle to be used for the intervals.

Setting it will ensure that we have randomised throttles between reads, making it more effective.

pub fn maybe_with_size_limit(self, limit: Option<usize>) -> InfiniteReader

Set a limit on how much data will be served, by default it will be an infinite amount of data.

pub fn maybe_set_size_limit( &mut self, limit: Option<usize>, ) -> &mut InfiniteReader

Set a limit on how much data will be served, by default it will be an infinite amount of data.

pub fn with_size_limit(self, limit: usize) -> InfiniteReader

Set a limit on how much data will be served, by default it will be an infinite amount of data.

pub fn set_size_limit(&mut self, limit: usize) -> &mut InfiniteReader

Set a limit on how much data will be served, by default it will be an infinite amount of data.

pub fn without_size_limit(self) -> InfiniteReader

Set a limit on how much data will be served, by default it will be an infinite amount of data.

pub fn unset_size_limit(&mut self) -> &mut InfiniteReader

Set a limit on how much data will be served, by default it will be an infinite amount of data.

pub fn with_chunk_size(self, size: usize) -> InfiniteReader

Define the chunk size for downloads.

The default value is used if a value of 0 is given.

pub fn set_chunk_size(&mut self, size: usize) -> &mut InfiniteReader

Define the chunk size for downloads.

The default value is used if a value of 0 is given.

pub fn into_body(self) -> Body

Turn this InfiniteReader into a Body.

Trait Implementations§

impl AsyncRead for InfiniteReader

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

Attempts to read from the AsyncRead into buf. Read more

impl Default for InfiniteReader

fn default() -> InfiniteReader

Returns the “default value” for a type. Read more

impl From<InfiniteReader> for Body

fn from(reader: InfiniteReader) -> Body

Converts to this type from the input type.

impl IntoResponse for InfiniteReader

fn into_response(self) -> Response

Create a response.

Auto Trait Implementations§

impl !RefUnwindSafe for InfiniteReader

impl !UnwindSafe for InfiniteReader

impl Freeze for InfiniteReader

impl Send for InfiniteReader

impl Sync for InfiniteReader

impl Unpin for InfiniteReader

impl UnsafeUnpin for InfiniteReader

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

impl<R> AsyncReadExt for R
where R: AsyncRead + ?Sized,

fn chain<R>(self, next: R) -> Chain<Self, R>
where Self: Sized, R: AsyncRead,

Creates a new AsyncRead instance that chains this stream with next. Read more

fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>
where Self: Unpin,

Pulls some bytes from this source into the specified buffer, returning how many bytes were read. Read more

fn read_buf<'a, B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B>
where Self: Unpin, B: BufMut + ?Sized,

Pulls some bytes from this source into the specified buffer, advancing the buffer’s internal cursor. Read more

fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self>
where Self: Unpin,

Reads the exact number of bytes required to fill buf. Read more

fn read_u8(&mut self) -> ReadU8<&mut Self>
where Self: Unpin,

Reads an unsigned 8 bit integer from the underlying reader. Read more

fn read_i8(&mut self) -> ReadI8<&mut Self>
where Self: Unpin,

Reads a signed 8 bit integer from the underlying reader. Read more

fn read_u16(&mut self) -> ReadU16<&mut Self>
where Self: Unpin,

Reads an unsigned 16-bit integer in big-endian order from the underlying reader. Read more

fn read_i16(&mut self) -> ReadI16<&mut Self>
where Self: Unpin,

Reads a signed 16-bit integer in big-endian order from the underlying reader. Read more

fn read_u32(&mut self) -> ReadU32<&mut Self>
where Self: Unpin,

Reads an unsigned 32-bit integer in big-endian order from the underlying reader. Read more

fn read_i32(&mut self) -> ReadI32<&mut Self>
where Self: Unpin,

Reads a signed 32-bit integer in big-endian order from the underlying reader. Read more

fn read_u64(&mut self) -> ReadU64<&mut Self>
where Self: Unpin,

Reads an unsigned 64-bit integer in big-endian order from the underlying reader. Read more

fn read_i64(&mut self) -> ReadI64<&mut Self>
where Self: Unpin,

Reads an signed 64-bit integer in big-endian order from the underlying reader. Read more

fn read_u128(&mut self) -> ReadU128<&mut Self>
where Self: Unpin,

Reads an unsigned 128-bit integer in big-endian order from the underlying reader. Read more

fn read_i128(&mut self) -> ReadI128<&mut Self>
where Self: Unpin,

Reads an signed 128-bit integer in big-endian order from the underlying reader. Read more

fn read_f32(&mut self) -> ReadF32<&mut Self>
where Self: Unpin,

Reads an 32-bit floating point type in big-endian order from the underlying reader. Read more

fn read_f64(&mut self) -> ReadF64<&mut Self>
where Self: Unpin,

Reads an 64-bit floating point type in big-endian order from the underlying reader. Read more

fn read_u16_le(&mut self) -> ReadU16Le<&mut Self>
where Self: Unpin,

Reads an unsigned 16-bit integer in little-endian order from the underlying reader. Read more

fn read_i16_le(&mut self) -> ReadI16Le<&mut Self>
where Self: Unpin,

Reads a signed 16-bit integer in little-endian order from the underlying reader. Read more

fn read_u32_le(&mut self) -> ReadU32Le<&mut Self>
where Self: Unpin,

Reads an unsigned 32-bit integer in little-endian order from the underlying reader. Read more

fn read_i32_le(&mut self) -> ReadI32Le<&mut Self>
where Self: Unpin,

Reads a signed 32-bit integer in little-endian order from the underlying reader. Read more

fn read_u64_le(&mut self) -> ReadU64Le<&mut Self>
where Self: Unpin,

Reads an unsigned 64-bit integer in little-endian order from the underlying reader. Read more

fn read_i64_le(&mut self) -> ReadI64Le<&mut Self>
where Self: Unpin,

Reads an signed 64-bit integer in little-endian order from the underlying reader. Read more

fn read_u128_le(&mut self) -> ReadU128Le<&mut Self>
where Self: Unpin,

Reads an unsigned 128-bit integer in little-endian order from the underlying reader. Read more

fn read_i128_le(&mut self) -> ReadI128Le<&mut Self>
where Self: Unpin,

Reads an signed 128-bit integer in little-endian order from the underlying reader. Read more

fn read_f32_le(&mut self) -> ReadF32Le<&mut Self>
where Self: Unpin,

Reads an 32-bit floating point type in little-endian order from the underlying reader. Read more

fn read_f64_le(&mut self) -> ReadF64Le<&mut Self>
where Self: Unpin,

Reads an 64-bit floating point type in little-endian order from the underlying reader. Read more

fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self>
where Self: Unpin,

Reads all bytes until EOF in this source, placing them into buf. Read more

fn read_to_string<'a>( &'a mut self, dst: &'a mut String, ) -> ReadToString<'a, Self>
where Self: Unpin,

Reads all bytes until EOF in this source, appending them to buf. Read more

fn take(self, limit: u64) -> Take<Self>
where Self: Sized,

Creates an adaptor which reads at most limit bytes from it. Read more

impl<T> AsyncReadOwned for T
where T: AsyncRead + Unpin + Send + ?Sized,

fn poll_read_owned<B>( &mut self, cx: &mut Context<'_>, slot: &mut BufSlot<B>, ) -> Poll<Result<usize, Error>>
where B: IoBufMut,

The primitive. Poll a read into the owned buffer in slot, returning the bytes read (0 = EOF). The buffer is moved through the read op: Read more

fn read_owned<B>( &mut self, buf: B, ) -> impl Future<Output = (Result<usize, Error>, B)> + Send
where B: IoBufMut, Self: Send,

Derived async convenience over poll_read_owned: move buf in, drive to completion, hand it back filled. Not a second impl: every owned reader gets it for free, relays and read_exact_into use it. Read more

impl<B> BodyExtractExt for B
where B: Into<Body> + Send + 'static,

async fn try_into_json<T>(self) -> Result<T, Box<dyn Error + Sync + Send>>
where T: DeserializeOwned + Send + 'static,

Try to deserialize the (contained) body as a JSON object. Read more

async fn try_into_json_streaming<T>( self, ) -> Result<T, Box<dyn Error + Sync + Send>>
where T: DeserializeOwned + Send + 'static,

Try to deserialize the (contained) body as a JSON object, streaming bytes from the body directly into the JSON parser instead of buffering the whole body first. Read more

async fn try_into_string(self) -> Result<String, Box<dyn Error + Sync + Send>>

Try to turn the (contained) body in an utf-8 string.

async fn try_capture_json( self, selectors: impl IntoIterator<Item = JsonPath> + Send, max_capture_bytes: usize, ) -> Result<Vec<OwnedCapturedValue>, Box<dyn Error + Sync + Send>>

Capture JSON values matching selectors while streaming over the body. Read more

async fn try_into_json_with<T>( self, opts: CollectOptions, ) -> Result<T, CollectError>
where T: DeserializeOwned + Send + 'static,

Like try_into_json, but bounded by opts (a size cap and/or timeout). Read more

async fn try_into_string_with( self, opts: CollectOptions, ) -> Result<String, CollectError>

Like try_into_string, but bounded by opts. See try_into_json_with for the error semantics.

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> FutureExt for T

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl<T> PolicyExt for T
where T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more

impl<T, U> RamaFrom<T> for U
where U: From<T>,

fn rama_from(value: T) -> U

impl<T, U, CrateMarker> RamaInto<U, CrateMarker> for T
where U: RamaFrom<T, CrateMarker>,

fn rama_into(self) -> U

impl<T, U> RamaTryFrom<T> for U
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn rama_try_from(value: T) -> Result<U, <U as RamaTryFrom<T>>::Error>

impl<T, U, CrateMarker> RamaTryInto<U, CrateMarker> for T
where U: RamaTryFrom<T, CrateMarker>,

type Error = <U as RamaTryFrom<T, CrateMarker>>::Error

fn rama_try_into(self) -> Result<U, <U as RamaTryFrom<T, CrateMarker>>::Error>

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

impl<T> Same for T

type Output = T

Should always be Self

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more