Struct jsonp::BackingBytes

pub struct BackingBytes<'a> { /* fields omitted */ }

Convenience wrapper around the library core functions for byte slices, removing some of the generic noise from function signatures.

Implementations

impl<'a> BackingBytes<'a>

pub fn new(borrow: &'a [u8]) -> Self

Instantiate a wrapper around the given byte slice.

pub fn with(borrow: &'a [u8], pointer: Pointer) -> Self

Instantiate a wrapper around the given byte slice and pointer.

pub fn dotted<'de, T>(&self, pointer: &str) -> Result<T, Error> where
    T: Deserialize<'de>,
    'a: 'de, 

See the documentation of Pointer::dotted.

Example

use jsonp::BackingBytes;

fn main() {
    let json = r#"{"outer": {"array": [0, "one", true]}}"#.as_bytes();
    let one: &str = BackingBytes::new(json).dotted("outer.array.1").unwrap();

    assert!(one == "one");
}

pub fn pattern<'de, T>(&self, pointer: &str, pattern: &str) -> Result<T, Error> where
    T: Deserialize<'de>,
    'a: 'de, 

See the documentation of Pointer::with_pattern.

Example

use jsonp::BackingBytes;
fn main() {
    let json = r#"{"outer": {"array": [0, "one", true]}}"#.as_bytes();
    let is_true: bool = BackingBytes::new(json).pattern("outer array 2", " ").unwrap();

    assert!(is_true);
}

pub fn pointer<'de, 'p, I, T>(&self, pointers: I) -> Result<T, Error> where
    I: IntoIterator<Item = Segment<'p>>,
    T: Deserialize<'de>,
    'a: 'de, 

See the documentation for Pointer::with_segments.

Example

use jsonp::{BackingBytes, Segment};
fn main() {
    let json = r#"{"outer": {"array": [0, 1, 2, 3]}}"#.as_bytes();
    let segments = &["outer", "array"];
    let array: Vec<i8> = BackingBytes::new(json)
        .pointer(segments.into_iter().copied().map(Segment::lazy))
        .unwrap();

    assert_eq!(&array, &[0, 1, 2, 3]);
}

Trait Implementations

impl<'a> Clone for BackingBytes<'a>

fn clone(&self) -> BackingBytes<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for BackingBytes<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a [u8]> for BackingBytes<'a>

fn from(backing: &'a [u8]) -> Self

Performs the conversion.