Struct streaming_http_range_client::HttpClient

pub struct HttpClient { /* private fields */ }

A stream centric HTTP client.

use streaming_http_range_client::HttpClient;
use tokio::io::AsyncReadExt;

use tokio;
let mut new_client = HttpClient::new("https://georust.org");
new_client.set_range(2..14).await.unwrap();

let mut output = String::new();
new_client.read_to_string(&mut output).await.unwrap();

// This `expected_text` may need to be updated someday if someone updates the site.
let expected_text = "DOCTYPE html";
assert_eq!(expected_text, output)

Implementations

impl HttpClient

pub fn test_client(data: &[u8]) -> Self

impl HttpClient

pub fn new(url: &str) -> Self

Create a new client. To get data from the client, call [set_range] and start reading from the client.

pub async fn set_range(&mut self, range: Range<u64>) -> Result<()>

pub async fn fast_forward(&mut self, to_pos: u64) -> Result<()>

Advance client to to_pos, discarding any intermediate data, without fetching further data.

to_pos must be within the current range and must not occur before the current position.

pub async fn seek_to_range(&mut self, range: impl Into<HttpRange>) -> Result<()>

Fast forwards to the beginning of range, fetching additional data if necessary.

pub async fn extend_to_end(&mut self) -> Result<()>

Fetch all the bytes to the end of the file.

Panics when the current range is:

• not set (see [set_range])
• an open ended (RangeFrom) range, since it can’t be extended

pub async fn append_contiguous_range( &mut self, extension: Range<u64> ) -> Result<()>

Append a contiguous extension to the current range.

Panics when the current range is:

• not set (see [set_range])
• an open ended (RangeFrom) range, since it can’t be extended
• not contiguous with the extension

pub fn split_off(&mut self) -> Self

Move all the unread data from this client into a new instance.

pub fn contains(&self, range: &HttpRange) -> bool

Does the client already encompass the given range?

Caveat: If the client’s current Range has an explicit end, we assume any given open ended (123..) Range goes beyond the current Range.

Trait Implementations

impl AsyncRead for HttpClient

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

Attempts to read from the AsyncRead into buf.

impl Debug for HttpClient

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

Formats the value using the given formatter.

impl Drop for HttpClient

fn drop(&mut self)

Executes the destructor for this type.