Struct ipfs_api_prelude::BackendWithGlobalOptions

pub struct BackendWithGlobalOptions<Back: Backend> { /* private fields */ }

A wrapper for Backend / IpfsApi that adds global options

Implementations

impl<Back: Backend> BackendWithGlobalOptions<Back>

pub fn into_inner(self) -> Back

Return the wrapped Backend

pub fn new(backend: Back, options: GlobalOptions) -> Self

Construct

While possible, it is not recommended to wrap a Backend twice.

Trait Implementations

impl<Back: Backend> Backend for BackendWithGlobalOptions<Back>

type HttpRequest = <Back as Backend>::HttpRequest

type HttpResponse = <Back as Backend>::HttpResponse

type Error = <Back as Backend>::Error

fn build_base_request<Req>(
    &self,
    req: Req,
    form: Option<Form<'static>>
) -> Result<Self::HttpRequest, Self::Error> where
    Req: ApiRequest, 

Builds the url for an api call.

fn get_header(res: &Self::HttpResponse, key: HeaderName) -> Option<&HeaderValue>

Get the value of a header from an HTTP response.

fn request_raw<'life0, 'async_trait, Req>(
    &'life0 self,
    req: Req,
    form: Option<Form<'static>>
) -> Pin<Box<dyn Future<Output = Result<(StatusCode, Bytes), Self::Error>> + 'async_trait>> where
    Req: ApiRequest,
    Req: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Generates a request, and returns the unprocessed response future.

fn response_to_byte_stream(
    res: Self::HttpResponse
) -> BoxStream<Bytes, Self::Error>

fn request_stream<Res, F>(
    &self,
    req: Self::HttpRequest,
    process: F
) -> BoxStream<Res, Self::Error> where
    F: 'static + Send + Fn(Self::HttpResponse) -> BoxStream<Res, Self::Error>, 

Generic method for making a request that expects back a streaming response.

fn process_error_from_body(body: Bytes) -> Self::Error

Builds an Api error from a response body.

fn process_json_response<Res>(
    status: StatusCode,
    body: Bytes
) -> Result<Res, Self::Error> where
    for<'de> Res: 'static + Deserialize<'de> + Send, 

Processes a response that expects a json encoded body, returning an error or a deserialized json response.

fn process_stream_response<D, Res>(
    res: Self::HttpResponse,
    decoder: D
) -> FramedRead<StreamReader<BoxStream<Bytes, Self::Error>>, D> where
    D: Decoder<Item = Res, Error = Error>, 

Processes a response that returns a stream of json deserializable results.

fn request<'life0, 'async_trait, Req, Res>(
    &'life0 self,
    req: Req,
    form: Option<Form<'static>>
) -> Pin<Box<dyn Future<Output = Result<Res, Self::Error>> + 'async_trait>> where
    Req: ApiRequest,
    for<'de> Res: 'static + Deserialize<'de> + Send,
    Req: 'async_trait,
    Res: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Generic method for making a request to the Ipfs server, and getting a deserializable response.

fn request_empty<'life0, 'async_trait, Req>(
    &'life0 self,
    req: Req,
    form: Option<Form<'static>>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + 'async_trait>> where
    Req: ApiRequest,
    Req: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Generic method for making a request to the Ipfs server, and getting back a response with no body.

fn request_string<'life0, 'async_trait, Req>(
    &'life0 self,
    req: Req,
    form: Option<Form<'static>>
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + 'async_trait>> where
    Req: ApiRequest,
    Req: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Generic method for making a request to the Ipfs server, and getting back a raw String response.

fn request_stream_bytes(
    &self,
    req: Self::HttpRequest
) -> BoxStream<Bytes, Self::Error>

Generic method for making a request to the Ipfs server, and getting back a raw stream of bytes.

fn request_stream_json<Res>(
    &self,
    req: Self::HttpRequest
) -> BoxStream<Res, Self::Error> where
    for<'de> Res: 'static + Deserialize<'de> + Send, 

Generic method to return a streaming response of deserialized json objects delineated by new line separators.