Struct rocket::data::Capped[−][src]

pub struct Capped<T> {
    pub value: T,
    pub n: N,
}

Expand description

Encapsulates a value capped to a data limit.

A Capped<T> type represents a T that has been limited (capped) to some number of bytes. The internal N specifies whether the value is complete (also Capped::is_complete()) or whether it was capped prematurely. A Capped is returned by various methods of DataStream. Some Capped<T> types, like Capped<String> and Capped<TempFile>, implement traits like FromData and FromForm.

Example

Since Capped<TempFile> implements FromData, it can be used as a data guard. The following Rocket route accepts a raw upload and stores the upload in a different directory depending on whether the file exceeded the data limit or not. See TempFile for details on temporary file storage locations and limits.

use rocket::data::Capped;
use rocket::fs::TempFile;

#[post("/upload", data = "<file>")]
async fn upload(mut file: Capped<TempFile<'_>>) -> std::io::Result<()> {
    if file.is_complete() {
        file.persist_to("/tmp/complete/file.txt").await?;
    } else {
        file.persist_to("/tmp/incomplete/file.txt").await?;
    }

    Ok(())
}

Fields

value: T

The capped value itself.

n: N

The number of bytes written and whether value is complete.

Implementations

`impl<T> Capped<T>`[src]

`pub fn new(value: T, n: N) -> Self`[src]

Creates a new Capped from a value and an n. Prefer to use Capped::from() when possible.

Example

use rocket::data::{Capped, N};

let n = N { written: 2, complete: true };
let capped = Capped::new("hi".to_string(), n);

`pub fn complete(value: T, len: usize) -> Self`[src]

Creates a new Capped from a value and the length of value n, marking value as complete. Prefer to use Capped::from() when possible.

Example

use rocket::data::{Capped, N};

let string = "hi";
let capped = Capped::complete("hi", string.len());

`pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Capped`[src]

Converts a Capped<T> to Capped by applying f to the contained value.

Example

use rocket::data::{Capped, N};

let n = N { written: 2, complete: true };
let capped: Capped<usize> = Capped::new(10usize, n);
let mapped: Capped<String> = capped.map(|n| n.to_string());

`pub fn is_empty(&self) -> bool`[src]

Returns true if self.n.written is 0, that is, no bytes were written to value.

Example

use rocket::data::{Capped, N};

let n = N { written: 2, complete: true };
let capped = Capped::new("hi".to_string(), n);
assert!(!capped.is_empty());

let n = N { written: 0, complete: true };
let capped = Capped::new("".to_string(), n);
assert!(capped.is_empty());

`pub fn is_complete(&self) -> bool`[src]

Returns true if self.n.complete, that is, value represents the entire data stream.

Example

use rocket::data::{Capped, N};

let n = N { written: 2, complete: true };
let capped = Capped::new("hi".to_string(), n);
assert!(capped.is_complete());

let n = N { written: 4, complete: false };
let capped = Capped::new("hell".to_string(), n);
assert!(!capped.is_complete());

`pub fn into_inner(self) -> T`[src]

Returns the internal value.

Example

use rocket::data::{Capped, N};

let n = N { written: 2, complete: true };
let capped = Capped::new("hi".to_string(), n);
assert_eq!(capped.into_inner(), "hi");

Trait Implementations

`impl<T: Clone> Clone for Capped<T>`[src]

`fn clone(&self) -> Capped<T>`[src]

Returns a copy of the value. Read more

`fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from source. Read more

`impl<T: Debug> Debug for Capped<T>`[src]

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

Formats the value using the given formatter. Read more

`impl<T> Deref for Capped<T>`[src]

`type Target = T`

The resulting type after dereferencing.

`fn deref(&self) -> &Self::Target`[src]

Dereferences the value.

`impl<T> DerefMut for Capped<T>`[src]

`fn deref_mut(&mut self) -> &mut Self::Target`[src]

Mutably dereferences the value.

`impl<T: AsRef<[u8]>> From<T> for Capped<T>`[src]