Struct bevy_internal::scene::ron::options::Options

#[non_exhaustive]
pub struct Options {
    pub default_extensions: Extensions,
    pub recursion_limit: Option<usize>,
}

Roundtrip serde options.

Examples

use ron::{Options, extensions::Extensions};

let ron = Options::default()
    .with_default_extension(Extensions::IMPLICIT_SOME);

let de: Option<i32> = ron.from_str("42").unwrap();
let ser = ron.to_string(&de).unwrap();

assert_eq!(ser, "42");

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

default_extensions: Extensions

Extensions that are enabled by default during serialization and deserialization. During serialization, these extensions do NOT have to be explicitly enabled in the parsed RON. During deserialization, these extensions are used, but their explicit activation is NOT included in the output RON. No extensions are enabled by default.

recursion_limit: Option<usize>

Default recursion limit that is checked during serialization and deserialization. If set to None, infinite recursion is allowed and stack overflow errors can crash the serialization or deserialization process. Defaults to Some(128), i.e. 128 recursive calls are allowed.

Implementations

impl Options

pub fn with_default_extension(self, default_extension: Extensions) -> Options

Enable default_extension by default during serialization and deserialization.

pub fn without_default_extension(self, default_extension: Extensions) -> Options

Do NOT enable default_extension by default during serialization and deserialization.

pub fn with_recursion_limit(self, recursion_limit: usize) -> Options

Set a maximum recursion limit during serialization and deserialization.

pub fn without_recursion_limit(self) -> Options

Disable the recursion limit during serialization and deserialization.

If you expect to handle highly recursive datastructures, consider wrapping ron with serde_stacker.

impl Options

pub fn from_reader<R, T>(&self, rdr: R) -> Result<T, SpannedError>

where R: Read, T: DeserializeOwned,

A convenience function for building a deserializer and deserializing a value of type T from a reader.

pub fn from_str<'a, T>(&self, s: &'a str) -> Result<T, SpannedError>

where T: Deserialize<'a>,

A convenience function for building a deserializer and deserializing a value of type T from a string.

pub fn from_bytes<'a, T>(&self, s: &'a [u8]) -> Result<T, SpannedError>

where T: Deserialize<'a>,

A convenience function for building a deserializer and deserializing a value of type T from bytes.

pub fn from_reader_seed<R, S, T>( &self, rdr: R, seed: S ) -> Result<T, SpannedError>

where R: Read, S: for<'a> DeserializeSeed<'a, Value = T>,

A convenience function for building a deserializer and deserializing a value of type T from a reader and a seed.

pub fn from_str_seed<'a, S, T>( &self, s: &'a str, seed: S ) -> Result<T, SpannedError>

where S: DeserializeSeed<'a, Value = T>,

A convenience function for building a deserializer and deserializing a value of type T from a string and a seed.

pub fn from_bytes_seed<'a, S, T>( &self, s: &'a [u8], seed: S ) -> Result<T, SpannedError>

where S: DeserializeSeed<'a, Value = T>,

A convenience function for building a deserializer and deserializing a value of type T from bytes and a seed.

pub fn to_writer<W, T>(&self, writer: W, value: &T) -> Result<(), Error>

where W: Write, T: Serialize + ?Sized,

Serializes value into writer.

This function does not generate any newlines or nice formatting; if you want that, you can use to_writer_pretty instead.

pub fn to_writer_pretty<W, T>( &self, writer: W, value: &T, config: PrettyConfig ) -> Result<(), Error>

where W: Write, T: Serialize + ?Sized,

Serializes value into writer in a pretty way.

pub fn to_string<T>(&self, value: &T) -> Result<String, Error>

where T: Serialize + ?Sized,

Serializes value and returns it as string.

This function does not generate any newlines or nice formatting; if you want that, you can use to_string_pretty instead.

pub fn to_string_pretty<T>( &self, value: &T, config: PrettyConfig ) -> Result<String, Error>

where T: Serialize + ?Sized,

Serializes value in the recommended RON layout in a pretty way.

Trait Implementations

impl Clone for Options

fn clone(&self) -> Options

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Options

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

Formats the value using the given formatter.

impl Default for Options

fn default() -> Options

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Options

where Options: Default,

fn deserialize<__D>( __deserializer: __D ) -> Result<Options, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Options

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.