Struct ron::options::Options

#[non_exhaustive]
pub struct Options {
    pub default_extensions: Extensions,
}

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.

Implementations

impl Options

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

Enable default_extension by default during serialization and deserialization.

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

Do NOT enable default_extension by default during serialization and deserialization.

impl Options

pub fn from_reader<R, T>(&self, rdr: R) -> SpannedResult<T> 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) -> SpannedResult<T> 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]) -> SpannedResult<T> 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) -> SpannedResult<T> 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) -> SpannedResult<T> 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) -> SpannedResult<T> 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<()> where
    W: Write,
    T: ?Sized + Serialize, 

Serializes value into writer

pub fn to_writer_pretty<W, T>(
    &self,
    writer: W,
    value: &T,
    config: PrettyConfig
) -> Result<()> where
    W: Write,
    T: ?Sized + Serialize, 

Serializes value into writer in a pretty way.

pub fn to_string<T>(&self, value: &T) -> Result<String> where
    T: ?Sized + Serialize, 

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> where
    T: ?Sized + Serialize, 

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

Formats the value using the given formatter.

impl Default for Options

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Options where
    Options: Default, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::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::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.