Struct RawJson 

pub struct RawJson<'a>(pub Cow<'a, str>);

A raw JSON value that has not been parsed.

This type captures the raw JSON text for a value, deferring parsing until you’re ready (or skipping it entirely if you just need to pass it through).

Example

use facet::Facet;
use facet_json::RawJson;

#[derive(Facet, Debug)]
struct Response<'a> {
    status: u32,
    // We don't know what shape `data` has, so defer parsing
    data: RawJson<'a>,
}

let json = r#"{"status": 200, "data": {"nested": [1, 2, 3], "complex": true}}"#;
let response: Response = facet_json::from_str_borrowed(json).unwrap();

assert_eq!(response.status, 200);
assert_eq!(response.data.as_str(), r#"{"nested": [1, 2, 3], "complex": true}"#);

Tuple Fields

0: Cow<'a, str>

Implementations

impl<'a> RawJson<'a>

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

Create a new RawJson from a string slice.

pub fn from_owned(s: String) -> Self

Create a new RawJson from an owned string.

pub fn as_str(&self) -> &str

Get the raw JSON as a string slice.

pub fn into_owned(self) -> RawJson<'static>

Convert into an owned RawJson<'static>.

Trait Implementations

impl<'a> AsRef<str> for RawJson<'a>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for RawJson<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RawJson<'_>

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

Formats the value using the given formatter.

impl Display for RawJson<'_>

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

Formats the value using the given formatter.

impl<'a, 'ʄ> Facet<'ʄ> for RawJson<'a>

where 'a: 'ʄ, 'ʄ: 'a,

const SHAPE: &'static Shape

The shape of this type, including: whether it’s a Struct, an Enum, something else?

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

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

Converts to this type from the input type.

impl<'a> From<Cow<'a, str>> for RawJson<'a>

fn from(s: Cow<'a, str>) -> Self

Converts to this type from the input type.

impl From<String> for RawJson<'static>

fn from(s: String) -> Self

Converts to this type from the input type.

impl<'a> Hash for RawJson<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for RawJson<'a>

fn eq(&self, other: &RawJson<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for RawJson<'a>

impl<'a> StructuralPartialEq for RawJson<'a>