Struct RawJson 

pub struct RawJson { /* private fields */ }

An owned piece of JSON text that travels through the SDK unchanged.

It holds whatever value it was built from - an object, an array or a scalar - as the text the wire carried, so a response field of a shape this version does not know survives a decode and can be read later with decode. Two values are equal when their text is equal, which means equality is textual: {"a":1} and { "a": 1 } are different values.

Invariant

The text is always exactly one complete JSON value whose structure is valid. Nothing builds a RawJson without the codec having established that, because the text is written into a request body unread: a second value in it would become a field of the enclosing object. Escapes inside strings are passed through unchecked: a \u escape with bad hex digits, or a lone surrogate half, is kept as it was written, and a strict server refuses the request that carries it. String boundaries are found the same way either way, so such an escape cannot end a string early.

Serialization

Inside the SDK the text is spliced into the request body byte for byte: key order, spacing and the exact spelling of every number are what the caller or the server wrote. Through any other serializer - serde_json, for instance - the value is written out as ordinary JSON data instead, so the data survives while its spelling may not: numbers are re-rendered by that serializer and insignificant whitespace is dropped.

Which of the two happens is decided by whether the SDK’s own encoder is running on this thread, not by the type of the serializer, because serde offers no way to ask a serializer what it is. A RawJson handed to a foreign serializer from inside a caller’s own Serialize implementation while the SDK is encoding a request is therefore spliced rather than transcoded; use as_str there.

Implementations

impl RawJson

pub fn from_value<T>(value: &T) -> Result<Self, EncodeError>

where T: Serialize + ?Sized,

Encodes value and keeps the resulting JSON text.

Errors

Returns EncodeError when the value cannot be represented as JSON.

pub fn as_str(&self) -> &str

The JSON text, exactly as it was received or encoded.

pub fn decode<'de, T>(&'de self) -> Result<T, DecodeError>

where T: Deserialize<'de>,

Decodes the held text into T.

It is decode rather than deserialize so that it does not shadow Deserialize::deserialize, which a caller reaches for when they read a RawJson out of a document with a codec of their own.

Errors

Returns DecodeError when the text does not have the shape T expects, or when it is nested deeper than the decoder allows - which a value built by from_value can be, since encoding is not depth limited.

Trait Implementations

impl Clone for RawJson

fn clone(&self) -> Self

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, formatter: &mut Formatter<'_>) -> Result

Prints the JSON text itself, with control characters and the format characters that reorder or hide text written as Rust escapes: JSON allows those raw inside a string, the text usually came from a server, and a {:?} usually ends up in a log line. Backslashes are kept as they are, since they are the JSON’s own escapes. Display, as_str and serialization give the text byte for byte. The default derive would wrap the text in a struct with one field and quote it a second time.

impl<'de> Deserialize<'de> for RawJson

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RawJson

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

Formats the value using the given formatter.

impl Eq for RawJson

impl Hash for RawJson

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 PartialEq for RawJson

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RawJson

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RawJson