Struct PrettyConfig

#[non_exhaustive]
pub struct PrettyConfig {

    pub depth_limit: usize,
    pub new_line: Cow<'static, str>,
    pub indentor: Cow<'static, str>,
    pub separator: Cow<'static, str>,
    pub struct_names: bool,
    pub separate_tuple_members: bool,
    pub enumerate_arrays: bool,
    pub extensions: Extensions,
    pub compact_arrays: bool,
    pub escape_strings: bool,
    pub compact_structs: bool,
    pub compact_maps: bool,
    pub number_suffixes: bool,
    pub path_meta: Option<Field>,
}

Pretty serializer configuration.

Examples

use ron::ser::PrettyConfig;

let my_config = PrettyConfig::new()
    .depth_limit(4)
    // definitely superior (okay, just joking)
    .indentor("\t");

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.

depth_limit: usize

Limit the pretty-ness up to the given depth.

new_line: Cow<'static, str>

New line string

indentor: Cow<'static, str>

Indentation string

separator: Cow<'static, str>

Separator string

struct_names: bool

separate_tuple_members: bool

Separate tuple members with indentation

enumerate_arrays: bool

Enumerate array items in comments

extensions: Extensions

Enable extensions. Only configures implicit_some, unwrap_newtypes, and unwrap_variant_newtypes for now.

compact_arrays: bool

Enable compact arrays, which do not insert new lines and indentation between the elements of an array

escape_strings: bool

Whether to serialize strings as escaped strings, or fall back onto raw strings if necessary.

compact_structs: bool

Enable compact structs, which do not insert new lines and indentation between the fields of a struct

compact_maps: bool

Enable compact maps, which do not insert new lines and indentation between the entries of a struct

number_suffixes: bool

Enable explicit number type suffixes like 1u16

path_meta: Option<Field>

Additional path-based field metadata to serialize

Implementations

impl PrettyConfig

pub fn new() -> Self

Creates a default PrettyConfig.

pub fn depth_limit(self, depth_limit: usize) -> Self

Limits the pretty-formatting based on the number of indentations. I.e., with a depth limit of 5, starting with an element of depth (indentation level) 6, everything will be put into the same line, without pretty formatting.

Default: usize::MAX

pub fn new_line(self, new_line: impl Into<Cow<'static, str>>) -> Self

Configures the newlines used for serialization.

Default: \r\n on Windows, \n otherwise

pub fn indentor(self, indentor: impl Into<Cow<'static, str>>) -> Self

Configures the string sequence used for indentation.

Default: 4 spaces

pub fn separator(self, separator: impl Into<Cow<'static, str>>) -> Self

Configures the string sequence used to separate items inline.

Default: 1 space

pub fn struct_names(self, struct_names: bool) -> Self

Configures whether to emit struct names.

See also Extensions::EXPLICIT_STRUCT_NAMES for the extension equivalent.

Default: false

pub fn separate_tuple_members(self, separate_tuple_members: bool) -> Self

Configures whether tuples are single- or multi-line. If set to true, tuples will have their fields indented and in new lines. If set to false, tuples will be serialized without any newlines or indentations.

Default: false

pub fn enumerate_arrays(self, enumerate_arrays: bool) -> Self

Configures whether a comment shall be added to every array element, indicating the index.

Default: false

pub fn compact_arrays(self, compact_arrays: bool) -> Self

Configures whether every array should be a single line (true) or a multi line one (false).

When false, ["a","b"] will serialize to

[
  "a",
  "b",
]

When true, ["a","b"] will instead serialize to

["a","b"]

Default: false

pub fn extensions(self, extensions: Extensions) -> Self

Configures extensions

Default: Extensions::empty()

pub fn escape_strings(self, escape_strings: bool) -> Self

Configures whether strings should be serialized using escapes (true) or fall back to raw strings if the string contains a " (false).

When true, "a\nb" will serialize to

"a\nb"

When false, "a\nb" will instead serialize to

"a
b"

Default: true

pub fn compact_structs(self, compact_structs: bool) -> Self

Configures whether every struct should be a single line (true) or a multi line one (false).

When false, Struct { a: 4, b: 2 } will serialize to

Struct(
    a: 4,
    b: 2,
)

When true, Struct { a: 4, b: 2 } will instead serialize to

Struct(a: 4, b: 2)

Default: false

pub fn compact_maps(self, compact_maps: bool) -> Self

Configures whether every map should be a single line (true) or a multi line one (false).

When false, a map with entries { "a": 4, "b": 2 } will serialize to

{
    "a": 4,
    "b": 2,
}

When true, a map with entries { "a": 4, "b": 2 } will instead serialize to

{"a": 4, "b": 2}

Default: false

pub fn number_suffixes(self, number_suffixes: bool) -> Self

Configures whether numbers should be printed without (false) or with (true) their explicit type suffixes.

When false, the integer 12345u16 will serialize to

12345

and the float 12345.6789f64 will serialize to

12345.6789

When true, the integer 12345u16 will serialize to

12345u16

and the float 12345.6789f64 will serialize to

12345.6789f64

Default: false

Trait Implementations

impl Clone for PrettyConfig

fn clone(&self) -> PrettyConfig

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PrettyConfig

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

Formats the value using the given formatter.

impl Default for PrettyConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PrettyConfig

where PrettyConfig: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PrettyConfig

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PrettyConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PrettyConfig

impl StructuralPartialEq for PrettyConfig