Struct abi_stable::external_types::serde_json::RawValueBox

pub struct RawValueBox { /* private fields */ }

An ffi-safe equivalent of Box<serde_json::value::RawValue>

Example

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

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

use serde::{Deserialize, Serialize};

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

let value = RawValueBox::try_from_string(JSON.to_string()).unwrap();

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

#[derive(Serialize)]
pub struct Pair {
    pub first: u64,
    pub second: RString,
}

#[derive(Debug, Deserialize)]
pub struct PairDeserialize {
    pub first: RawValueBox,
    pub second: RawValueBox,
}

#[sabi_extern_fn]
fn deserialize_data_structure(
    input: RStr<'_>,
) -> RResult<PairDeserialize, 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: 99,
    second: "How many apples?".into(),
})
.unwrap();

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

assert_eq!(pair.first.get(), "99");
assert_eq!(pair.second.get(), r##""How many apples?"}"##);

Implementations

impl RawValueBox

pub unsafe fn from_string_unchecked(input: String) -> RawValueBox

Converts a String to an RawValueBox 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::RawValueBox;

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

let value = unsafe { RawValueBox::from_string_unchecked(JSON.to_string()) };

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

pub const unsafe fn from_rstring_unchecked(input: RString) -> RawValueBox

Converts an RString to an RawValueBox 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::RawValueBox, std_types::RString};

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

let json_rstring = RString::from(JSON);
let value = unsafe { RawValueBox::from_rstring_unchecked(json_rstring) };

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

pub fn try_from_string(input: String) -> Result<Self, JsonError>

Attempts to convert a String into a RawValueBox.

Fails in the same cases as converting a String into a Box<RawValue> does.

Example

use abi_stable::{external_types::RawValueBox, std_types::RString};

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

let raw = RawValueBox::try_from_string(JSON.to_string()).unwrap();

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

pub fn get(&self) -> &str

Gets the json being serialized,as a &str.

Example

use abi_stable::external_types::RawValueBox;

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

let raw = serde_json::from_str::<RawValueBox>(JSON).unwrap();

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

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

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

Example

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

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

let raw = serde_json::from_str::<RawValueBox>(JSON).unwrap();

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

pub fn as_raw_value_ref(&self) -> RawValueRef<'_>

Gets a RawValueRef<’_> borrowing from this RawValueBox.

Example

use abi_stable::external_types::{RawValueBox, RawValueRef};

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

let raw = serde_json::from_str::<RawValueBox>(JSON).unwrap();

assert_eq!(raw.get(), RawValueRef::try_from_str(JSON).unwrap().get());

Trait Implementations

impl Clone for RawValueBox

fn clone(&self) -> RawValueBox

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RawValueBox

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RawValueBox

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RawValueBox

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

Formats the value using the given formatter.

impl From<Box<RawValue>> for RawValueBox

fn from(v: Box<RawValue>) -> Self

Converts to this type from the input type.

impl GetStaticEquivalent_ for RawValueBox

type StaticEquivalent = _static_RawValueBox

The 'static equivalent of Self

impl Serialize for RawValueBox

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

where Z: Serializer,

Serialize this value into the given Serde serializer.

impl StableAbi for RawValueBox

type IsNonZeroType = <RString 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 TryFrom<String> for RawValueBox

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: String) -> Result<Self, JsonError>

Performs the conversion.