Struct BackingStr

pub struct BackingStr<'a> { /* private fields */ }

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

Implementations

impl<'a> BackingStr<'a>

pub fn new(borrow: &'a str) -> Self

Instantiate a wrapper around the given string slice.

pub fn with(borrow: &'a str, p: Pointer) -> Self

Instantiate a wrapper around the given string 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::BackingStr;

let json = r#"{"outer": {"array": [0, "one", true]}}"#;
let one: &str = BackingStr::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::BackingStr;

let json = r#"{"outer": {"array": [0, "one", true]}}"#;
let is_true: bool = BackingStr::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::{BackingStr, Segment};

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

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

Trait Implementations

impl<'a> Clone for BackingStr<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BackingStr<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for BackingStr<'a>

fn from(backing: &'a str) -> Self

Converts to this type from the input type.