[−][src]Struct sane::ser::Serializer
Serialization implementation for SANE.
This structure implements serialization support for SANE to serialize an arbitrary type to SANE. Note that the SANE format does not support all datatypes in Rust, such as enums, tuples, and tuple structs. These types will generate an error when serialized.
Currently a serializer always writes its output to an in-memory String
,
which is passed in when creating the serializer itself.
Methods
impl<'a> Serializer<'a>
[src]
pub fn new(dst: &'a mut String) -> Serializer<'a>
[src]
Creates a new serializer which will emit SANE into the buffer provided.
The serializer can then be used to serialize a type after which the data
will be present in dst
.
pub fn pretty(dst: &'a mut String) -> Serializer<'a>
[src]
Instantiate a "pretty" formatter
By default this will use:
- pretty strings: strings with newlines will use the
'''
syntax. SeeSerializer::pretty_string
- pretty arrays: each item in arrays will be on a newline, have an indentation of 4 and
have a trailing comma. See
Serializer::pretty_array
pub fn pretty_string(&mut self, value: bool) -> &mut Self
[src]
Enable or Disable pretty strings
If enabled, literal strings will be used when possible and strings with
one or more newlines will use triple quotes (i.e.: '''
or """
)
Examples
Instead of:
single = "no newlines"
text = "\nfoo\nbar\n"
You will have:
single = 'no newlines'
text = '''
foo
bar
'''
pub fn pretty_string_literal(&mut self, value: bool) -> &mut Self
[src]
Enable or Disable Literal strings for pretty strings
If enabled, literal strings will be used when possible and strings with
one or more newlines will use triple quotes (i.e.: '''
or """
)
If disabled, literal strings will NEVER be used and strings with one or
more newlines will use """
Examples
Instead of:
single = "no newlines"
text = "\nfoo\nbar\n"
You will have:
single = "no newlines"
text = """
foo
bar
"""
pub fn pretty_array(&mut self, value: bool) -> &mut Self
[src]
Enable or Disable pretty arrays
If enabled, arrays will always have each item on their own line.
Some specific features can be controlled via other builder methods:
Serializer::pretty_array_indent
: set the indent to a value other than 4.Serializer::pretty_array_trailing_comma
: enable/disable the trailing comma on the last item.
Examples
Instead of:
array = ["foo", "bar"]
You will have:
array = [
"foo",
"bar",
]
pub fn pretty_array_indent(&mut self, value: usize) -> &mut Self
[src]
Set the indent for pretty arrays
See Serializer::pretty_array
for more details.
pub fn pretty_array_trailing_comma(&mut self, value: bool) -> &mut Self
[src]
Specify whether to use a trailing comma when serializing pretty arrays
See Serializer::pretty_array
for more details.
Trait Implementations
impl<'a, 'b> Serializer for &'b mut Serializer<'a>
[src]
type Ok = ()
The output type produced by this Serializer
during successful serialization. Most serializers that produce text or binary output should set Ok = ()
and serialize into an [io::Write
] or buffer contained within the Serializer
instance. Serializers that build in-memory data structures may be simplified by using Ok
to propagate the data structure around. Read more
type Error = Error
The error type when some error occurs during serialization.
type SerializeSeq = SerializeSeq<'a, 'b>
Type returned from [serialize_seq
] for serializing the content of the sequence. Read more
type SerializeTuple = SerializeSeq<'a, 'b>
Type returned from [serialize_tuple
] for serializing the content of the tuple. Read more
type SerializeTupleStruct = SerializeSeq<'a, 'b>
Type returned from [serialize_tuple_struct
] for serializing the content of the tuple struct. Read more
type SerializeTupleVariant = SerializeSeq<'a, 'b>
Type returned from [serialize_tuple_variant
] for serializing the content of the tuple variant. Read more
type SerializeMap = SerializeTable<'a, 'b>
Type returned from [serialize_map
] for serializing the content of the map. Read more
type SerializeStruct = SerializeTable<'a, 'b>
Type returned from [serialize_struct
] for serializing the content of the struct. Read more
type SerializeStructVariant = Impossible<(), Error>
Type returned from [serialize_struct_variant
] for serializing the content of the struct variant. Read more
fn serialize_bool(self, v: bool) -> Result<(), Self::Error>
[src]
fn serialize_i8(self, v: i8) -> Result<(), Self::Error>
[src]
fn serialize_i16(self, v: i16) -> Result<(), Self::Error>
[src]
fn serialize_i32(self, v: i32) -> Result<(), Self::Error>
[src]
fn serialize_i64(self, v: i64) -> Result<(), Self::Error>
[src]
fn serialize_u8(self, v: u8) -> Result<(), Self::Error>
[src]
fn serialize_u16(self, v: u16) -> Result<(), Self::Error>
[src]
fn serialize_u32(self, v: u32) -> Result<(), Self::Error>
[src]
fn serialize_u64(self, v: u64) -> Result<(), Self::Error>
[src]
fn serialize_f32(self, v: f32) -> Result<(), Self::Error>
[src]
fn serialize_f64(self, v: f64) -> Result<(), Self::Error>
[src]
fn serialize_char(self, v: char) -> Result<(), Self::Error>
[src]
fn serialize_str(self, value: &str) -> Result<(), Self::Error>
[src]
fn serialize_bytes(self, value: &[u8]) -> Result<(), Self::Error>
[src]
fn serialize_none(self) -> Result<(), Self::Error>
[src]
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<(), Self::Error> where
T: Serialize,
[src]
T: Serialize,
fn serialize_unit(self) -> Result<(), Self::Error>
[src]
fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error>
[src]
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str
) -> Result<(), Self::Error>
[src]
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str
) -> Result<(), Self::Error>
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T
) -> Result<(), Self::Error> where
T: Serialize,
[src]
self,
_name: &'static str,
value: &T
) -> Result<(), Self::Error> where
T: Serialize,
fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T
) -> Result<(), Self::Error> where
T: Serialize,
[src]
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T
) -> Result<(), Self::Error> where
T: Serialize,
fn serialize_seq(
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Self::Error>
[src]
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Self::Error>
fn serialize_tuple(
self,
len: usize
) -> Result<Self::SerializeTuple, Self::Error>
[src]
self,
len: usize
) -> Result<Self::SerializeTuple, Self::Error>
fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>
[src]
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant, Self::Error>
[src]
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant, Self::Error>
fn serialize_map(
self,
_len: Option<usize>
) -> Result<Self::SerializeMap, Self::Error>
[src]
self,
_len: Option<usize>
) -> Result<Self::SerializeMap, Self::Error>
fn serialize_struct(
self,
name: &'static str,
_len: usize
) -> Result<Self::SerializeStruct, Self::Error>
[src]
self,
name: &'static str,
_len: usize
) -> Result<Self::SerializeStruct, Self::Error>
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeStructVariant, Self::Error>
[src]
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeStructVariant, Self::Error>
fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>
[src]
Serialize an i128
value. Read more
fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>
[src]
Serialize a u128
value. Read more
fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
[src]
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
Collect an iterator as a sequence. Read more
fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator<Item = (K, V)>,
K: Serialize,
V: Serialize,
[src]
I: IntoIterator<Item = (K, V)>,
K: Serialize,
V: Serialize,
Collect an iterator as a map. Read more
fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
Serialize a string produced by an implementation of Display
. Read more
fn is_human_readable(&self) -> bool
[src]
Determine whether Serialize
implementations should serialize in human-readable form. Read more
Auto Trait Implementations
impl<'a> !Send for Serializer<'a>
impl<'a> !Sync for Serializer<'a>
Blanket Implementations
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From for T
[src]
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,