Struct abi_stable::external_types::serde_json::RawValueRef

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

Available on crate feature serde_json only.

An ffi-safe equivalent of &serde_json::value::RawValue

Example

This defines a function that serializes a struct, and deserializes the json into another one with RawValueRef fields.

use abi_stable::{
    external_types::RawValueRef,
    sabi_extern_fn,
    std_types::{RBoxError, RErr, ROk, RResult, RStr, RString},
};

use serde::{Deserialize, Serialize};

use std::collections::HashMap;

const JSON: &'static str = r##"{"hello":"world"}"##;

let value = RawValueRef::try_from_str(JSON).unwrap();

assert_eq!(serde_json::to_string(&value).unwrap().as_str(), JSON);

#[derive(Serialize)]
pub struct Pair {
    pub first: Vec<u32>,
    pub second: HashMap<RString, RString>,
}

#[derive(Debug, Deserialize)]
pub struct PairDeserialize<'a> {
    #[serde(borrow)]
    pub first: RawValueRef<'a>,

    #[serde(borrow)]
    pub second: RawValueRef<'a>,
}

#[sabi_extern_fn]
fn deserialize_data_structure<'de>(
    input: RStr<'de>,
) -> RResult<PairDeserialize<'de>, RBoxError> {
    match serde_json::from_str::<PairDeserialize>(input.into()) {
        Ok(x) => ROk(x),
        Err(x) => RErr(RBoxError::new(x)),
    }
}


let json = serde_json::to_string(&Pair {
    first: vec![0, 1, 2],
    second: vec![(RString::from("hello"), "world".into())]
        .into_iter()
        .collect(),
})
.unwrap();

let pair = deserialize_data_structure(json.as_str().into()).unwrap();

assert_eq!(pair.first.get(), "[0,1,2]");
assert_eq!(pair.second.get(), r##"{"hello":"world"}"##);

Implementations

impl<'a> RawValueRef<'a>

pub const unsafe fn from_str_unchecked(input: &'a str) -> RawValueRef<'a>

Converts a &str to a RawValueRef<'a> without checking whether it is valid JSON.

Safety

input must be valid JSON and contain no leading or trailing whitespace.

Example

use abi_stable::external_types::RawValueRef;

const JSON: &'static str = r##"{"huh":"that is interesting"}"##;

const VALUE: RawValueRef<'_> = unsafe { RawValueRef::from_str_unchecked(JSON) };

assert_eq!(serde_json::to_string(&VALUE).unwrap().as_str(), JSON);

pub const unsafe fn from_rstr_unchecked(input: RStr<'a>) -> RawValueRef<'a>

Converts a RStr<'a> to a RawValueRef<'a> without checking whether it is valid JSON.

Safety

input must be valid JSON and contain no leading or trailing whitespace.

Example

use abi_stable::{external_types::RawValueRef, std_types::RStr};

const JSON: &'static str = r##"{"huh":"that is interesting"}"##;

let json_rstr = RStr::from(JSON);
let value = unsafe { RawValueRef::from_rstr_unchecked(json_rstr) };

assert_eq!(serde_json::to_string(&value).unwrap().as_str(), JSON);

pub fn try_from_str(input: &'a str) -> Result<Self, JsonError>

Attempts to convert a &'a str into a RawValueRef<'a>.

Fails in the same cases as parsing a &'a RawValue from a string does.

Example

use abi_stable::{external_types::RawValueRef, std_types::RStr};

const JSON: &'static str = r##"{"nope":"oof"}"##;

let raw = RawValueRef::try_from_str(JSON).unwrap();

assert_eq!(raw.get(), JSON);

pub fn get(&self) -> &'a str

Gets the json being serialized,as a &str.

Example

use abi_stable::external_types::RawValueRef;

const JSON: &'static str = r##"{"huh":1007}"##;

let raw = serde_json::from_str::<RawValueRef<'static>>(JSON).unwrap();

assert_eq!(raw.get(), JSON);

pub const fn get_rstr(&self) -> RStr<'a>

Gets the json being serialized,as a RStr<'a>.

Example

use abi_stable::{external_types::RawValueRef, std_types::RStr};

const JSON: &'static str = r##"{"bugs":"life"}"##;

let raw = serde_json::from_str::<RawValueRef<'static>>(JSON).unwrap();

assert_eq!(raw.get_rstr(), RStr::from(JSON));

Trait Implementations

impl<'a> Clone for RawValueRef<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RawValueRef<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for RawValueRef<'a>

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Display for RawValueRef<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a RawValue> for RawValueRef<'a>

fn from(v: &'a RawValue) -> Self

Converts to this type from the input type.

impl<'a> GetStaticEquivalent_ for RawValueRef<'a>

type StaticEquivalent = _static_RawValueRef<'static>

The 'static equivalent of Self

impl<'a> Serialize for RawValueRef<'a>

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

where Z: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StableAbi for RawValueRef<'a>

type IsNonZeroType = <RStr<'a> as StableAbi>::IsNonZeroType

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl<'a> TryFrom<&'a str> for RawValueRef<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: &'a str) -> Result<Self, JsonError>

Performs the conversion.

impl<'a> Copy for RawValueRef<'a>