Struct data_rw::Data

pub struct Data { /* fields omitted */ }

Implementations

impl Data

pub fn write_to_le<T: Writer>(&mut self, p: &T)

pub fn write_to<T: Writer>(&mut self, p: &T)

pub fn write_to_bit7<T: Writer>(&mut self, p: &T)

impl Data

pub fn get<T: Reader>(&mut self) -> Result<T>

pub fn get_le<T: Reader>(&mut self) -> Result<T>

pub fn get_bit7<T: Reader>(&mut self) -> Result<(usize, T)>

impl Data

pub fn serde_serialize<T: Serialize>(
    &mut self,
    value: T
) -> Result<(), DataError>

impl Data

pub fn serde_deserialize<'a, 'de, T: Deserialize<'a>>(
    &'de mut self
) -> Result<T, DataError>

impl Data

pub fn pack_to<'a, T: Deserialize<'a>>(&'a mut self) -> Result<T>

pub fn pack_from<T: Serialize>(value: T) -> Result<Data>

pub fn pack_deserialize<'a, T: Deserialize<'a>>(&'a mut self) -> Result<T>

pub fn pack_serialize<T: Serialize>(&mut self, value: T) -> Result<()>

impl Data

pub fn new() -> Data

pub fn with_capacity(cap: usize) -> Data

pub fn with_len(len: usize, default: u8) -> Data

pub fn get_position(&self) -> usize

获取OFFSET

pub fn set_position(&mut self, offset: usize) -> bool

设置OFFSET

pub fn len(&self) -> usize

长度

pub fn have_len(&self) -> usize

pub fn reset(&mut self)

重置

pub fn resize(&mut self, new_len: usize, value: u8)

重置长度

pub fn clear(&mut self)

清理

pub fn write(&mut self, buff: &[u8])

写入buff

pub fn write_ptr(&mut self, buff: *const u8, len: usize)

pub fn read(&mut self, len: usize) -> Result<Vec<u8>>

读取buff

pub fn bit7_write_u16(&mut self, value: &u16)

写入变成U16

pub fn bit7_write_u32(&mut self, value: &u32)

写入变成U32

pub fn bit7_write_u64(&mut self, value: &u64)

写入变成U64

pub fn bit7_write_i16(&mut self, value: &i16)

写入变长i64

pub fn bit7_write_i32(&mut self, value: &i32)

写入变长i32

pub fn bit7_write_i64(&mut self, value: &i64)

写入变长i64

pub fn bit7_write_f32(&mut self, value: &f32)

pub fn bit7_write_f64(&mut self, value: &f64)

pub fn bit7_write_u128(&mut self, value: &u128)

pub fn bit7_write_i128(&mut self, value: &i128)

pub fn read_bit7_u16(&mut self) -> Result<(usize, u16)>

读取变长 u16

pub fn read_bit7_i16(&mut self) -> Result<(usize, i16)>

读取变长i16

pub fn read_bit7_u32(&mut self) -> Result<(usize, u32)>

读取变长u32

pub fn read_bit7_i32(&mut self) -> Result<(usize, i32)>

读取变长i32

pub fn read_bit7_u64(&mut self) -> Result<(usize, u64)>

读取变长u64

pub fn read_bit7_i64(&mut self) -> Result<(usize, i64)>

读取变长i64

pub fn read_bit7_i128(&mut self) -> Result<(usize, i128)>

pub fn read_bit7_u128(&mut self) -> Result<(usize, u128)>

pub fn read_bit7_f32(&mut self) -> Result<(usize, f32)>

pub fn read_bit7_f64(&mut self) -> Result<(usize, f64)>

pub fn write_buff_bit7(&mut self, data: &[u8])

写入二进制变长长度

pub fn write_buff_fixed_le(&mut self, data: &[u8])

写入二进制定长长度 u32 le

pub fn write_buff_fixed(&mut self, data: &[u8])

写入二进制定长长度 u32

pub fn write_str_bit7(&mut self, data: &str)

写入字符串变长长度

pub fn write_str_fixed_le(&mut self, data: &str)

写入字符串定长长度 u32 le

pub fn write_str_fixed(&mut self, data: &str)

写入字符串定长长度 u32

pub fn get_buff_bit7(&mut self) -> Result<(usize, Vec<u8>)>

读取二进制 变长长度

pub fn get_str_bit7(&mut self) -> Result<(usize, String)>

读取字符串 变长

pub fn get_buff_fixed_le(&mut self) -> Result<Vec<u8>>

读取二进制 U32 LE

pub fn get_str_fixed_le(&mut self) -> Result<String>

读取字符串 U32 LE

pub fn get_buff_fixed(&mut self) -> Result<Vec<u8>>

获取二进制 定长 u32

pub fn get_str_fixed(&mut self) -> Result<String>

获取字符串 定长u32

Trait Implementations

impl Buf for Data

fn remaining(&self) -> usize

Returns the number of bytes between the current position and the end of the buffer.

fn bytes(&self) -> &[u8]

Returns a slice starting at the current position and of length between 0 and Buf::remaining(). Note that this can return shorter slice (this allows non-continuous internal representation).

fn advance(&mut self, cnt: usize)

Advance the internal cursor of the Buf

fn bytes_vectored(&'a self, dst: &mut [IoSlice<'a>]) -> usize

Fills dst with potentially multiple slices starting at self’s current position.

fn has_remaining(&self) -> bool

Returns true if there are any more bytes to consume

fn copy_to_slice(&mut self, dst: &mut [u8])

Copies bytes from self into dst.

fn get_u8(&mut self) -> u8

Gets an unsigned 8 bit integer from self.

fn get_i8(&mut self) -> i8

Gets a signed 8 bit integer from self.

fn get_u16(&mut self) -> u16

Gets an unsigned 16 bit integer from self in big-endian byte order.

fn get_u16_le(&mut self) -> u16

Gets an unsigned 16 bit integer from self in little-endian byte order.

fn get_i16(&mut self) -> i16

Gets a signed 16 bit integer from self in big-endian byte order.

fn get_i16_le(&mut self) -> i16

Gets a signed 16 bit integer from self in little-endian byte order.

fn get_u32(&mut self) -> u32

Gets an unsigned 32 bit integer from self in the big-endian byte order.

fn get_u32_le(&mut self) -> u32

Gets an unsigned 32 bit integer from self in the little-endian byte order.

fn get_i32(&mut self) -> i32

Gets a signed 32 bit integer from self in big-endian byte order.

fn get_i32_le(&mut self) -> i32

Gets a signed 32 bit integer from self in little-endian byte order.

fn get_u64(&mut self) -> u64

Gets an unsigned 64 bit integer from self in big-endian byte order.

fn get_u64_le(&mut self) -> u64

Gets an unsigned 64 bit integer from self in little-endian byte order.

fn get_i64(&mut self) -> i64

Gets a signed 64 bit integer from self in big-endian byte order.

fn get_i64_le(&mut self) -> i64

Gets a signed 64 bit integer from self in little-endian byte order.

fn get_u128(&mut self) -> u128

Gets an unsigned 128 bit integer from self in big-endian byte order.

fn get_u128_le(&mut self) -> u128

Gets an unsigned 128 bit integer from self in little-endian byte order.

fn get_i128(&mut self) -> i128

Gets a signed 128 bit integer from self in big-endian byte order.

fn get_i128_le(&mut self) -> i128

Gets a signed 128 bit integer from self in little-endian byte order.

fn get_uint(&mut self, nbytes: usize) -> u64

Gets an unsigned n-byte integer from self in big-endian byte order.

fn get_uint_le(&mut self, nbytes: usize) -> u64

Gets an unsigned n-byte integer from self in little-endian byte order.

fn get_int(&mut self, nbytes: usize) -> i64

Gets a signed n-byte integer from self in big-endian byte order.

fn get_int_le(&mut self, nbytes: usize) -> i64

Gets a signed n-byte integer from self in little-endian byte order.

fn get_f32(&mut self) -> f32

Gets an IEEE754 single-precision (4 bytes) floating point number from self in big-endian byte order.

fn get_f32_le(&mut self) -> f32

Gets an IEEE754 single-precision (4 bytes) floating point number from self in little-endian byte order.

fn get_f64(&mut self) -> f64

Gets an IEEE754 double-precision (8 bytes) floating point number from self in big-endian byte order.

fn get_f64_le(&mut self) -> f64

Gets an IEEE754 double-precision (8 bytes) floating point number from self in little-endian byte order.

fn copy_to_bytes(&mut self, len: usize) -> Bytes

Consumes len bytes inside self and returns new instance of Bytes with this data.

fn take(self, limit: usize) -> Take<Self>

Creates an adaptor which will read at most limit bytes from self.

fn chain<U>(self, next: U) -> Chain<Self, U> where
    U: Buf, 

Creates an adaptor which will chain this buffer with another.

fn reader(self) -> Reader<Self>

Creates an adaptor which implements the Read trait for self.

impl BufMut for Data

fn remaining_mut(&self) -> usize

Returns the number of bytes that can be written from the current position until the end of the buffer is reached.

unsafe fn advance_mut(&mut self, cnt: usize)

Advance the internal cursor of the BufMut

fn bytes_mut(&mut self) -> &mut UninitSlice

Returns a mutable slice starting at the current BufMut position and of length between 0 and BufMut::remaining_mut(). Note that this can be shorter than the whole remainder of the buffer (this allows non-continuous implementation).

fn has_remaining_mut(&self) -> bool

Returns true if there is space in self for more bytes.

fn put<T>(&mut self, src: T) where
    T: Buf, 

Transfer bytes into self from src and advance the cursor by the number of bytes written.

fn put_slice(&mut self, src: &[u8])

Transfer bytes into self from src and advance the cursor by the number of bytes written.

fn put_u8(&mut self, n: u8)

Writes an unsigned 8 bit integer to self.

fn put_i8(&mut self, n: i8)

Writes a signed 8 bit integer to self.

fn put_u16(&mut self, n: u16)

Writes an unsigned 16 bit integer to self in big-endian byte order.

fn put_u16_le(&mut self, n: u16)

Writes an unsigned 16 bit integer to self in little-endian byte order.

fn put_i16(&mut self, n: i16)

Writes a signed 16 bit integer to self in big-endian byte order.

fn put_i16_le(&mut self, n: i16)

Writes a signed 16 bit integer to self in little-endian byte order.

fn put_u32(&mut self, n: u32)

Writes an unsigned 32 bit integer to self in big-endian byte order.

fn put_u32_le(&mut self, n: u32)

Writes an unsigned 32 bit integer to self in little-endian byte order.

fn put_i32(&mut self, n: i32)

Writes a signed 32 bit integer to self in big-endian byte order.

fn put_i32_le(&mut self, n: i32)

Writes a signed 32 bit integer to self in little-endian byte order.

fn put_u64(&mut self, n: u64)

Writes an unsigned 64 bit integer to self in the big-endian byte order.

fn put_u64_le(&mut self, n: u64)

Writes an unsigned 64 bit integer to self in little-endian byte order.

fn put_i64(&mut self, n: i64)

Writes a signed 64 bit integer to self in the big-endian byte order.

fn put_i64_le(&mut self, n: i64)

Writes a signed 64 bit integer to self in little-endian byte order.

fn put_u128(&mut self, n: u128)

Writes an unsigned 128 bit integer to self in the big-endian byte order.

fn put_u128_le(&mut self, n: u128)

Writes an unsigned 128 bit integer to self in little-endian byte order.

fn put_i128(&mut self, n: i128)

Writes a signed 128 bit integer to self in the big-endian byte order.

fn put_i128_le(&mut self, n: i128)

Writes a signed 128 bit integer to self in little-endian byte order.

fn put_uint(&mut self, n: u64, nbytes: usize)

Writes an unsigned n-byte integer to self in big-endian byte order.

fn put_uint_le(&mut self, n: u64, nbytes: usize)

Writes an unsigned n-byte integer to self in the little-endian byte order.

fn put_int(&mut self, n: i64, nbytes: usize)

Writes a signed n-byte integer to self in big-endian byte order.

fn put_int_le(&mut self, n: i64, nbytes: usize)

Writes a signed n-byte integer to self in little-endian byte order.

fn put_f32(&mut self, n: f32)

Writes an IEEE754 single-precision (4 bytes) floating point number to self in big-endian byte order.

fn put_f32_le(&mut self, n: f32)

Writes an IEEE754 single-precision (4 bytes) floating point number to self in little-endian byte order.

fn put_f64(&mut self, n: f64)

Writes an IEEE754 double-precision (8 bytes) floating point number to self in big-endian byte order.

fn put_f64_le(&mut self, n: f64)

Writes an IEEE754 double-precision (8 bytes) floating point number to self in little-endian byte order.

fn limit(self, limit: usize) -> Limit<Self>

Creates an adaptor which can write at most limit bytes to self.

fn writer(self) -> Writer<Self>

Creates an adaptor which implements the Write trait for self.

fn chain_mut<U>(self, next: U) -> Chain<Self, U> where
    U: BufMut, 

Creates an adapter which will chain this buffer with another.

impl Clone for Data

fn clone(&self) -> Data

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Data

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

Formats the value using the given formatter.

impl Default for Data

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Data

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Data

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, 'a> Deserializer<'de> for &'a mut Data

type Error = DataError

The error type that can be returned if some error occurs during deserialization.

fn deserialize_any<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input.

fn deserialize_bool<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a bool value.

fn deserialize_i8<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_u8<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_i16<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_u16<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_i32<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_u32<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_i64<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_u64<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_f32<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_char<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_string<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_bytes<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_byte_buf<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a byte array and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_option<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an optional value.

fn deserialize_unit<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a unit value.

fn deserialize_unit_struct<V>(
    self,
    _name: &'static str,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a unit struct with a particular name.

fn deserialize_newtype_struct<V>(
    self,
    _name: &'static str,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a newtype struct with a particular name.

fn deserialize_seq<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a sequence of values.

fn deserialize_tuple<V>(
    self,
    _len: usize,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a sequence of values and knows how many values there are without looking at the serialized data.

fn deserialize_tuple_struct<V>(
    self,
    _name: &'static str,
    _len: usize,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a tuple struct with a particular name and number of fields.

fn deserialize_map<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a map of key-value pairs.

fn deserialize_struct<V>(
    self,
    _name: &'static str,
    _fields: &'static [&'static str],
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting a struct with a particular name and fields.

fn deserialize_enum<V>(
    self,
    _name: &'static str,
    _variants: &'static [&'static str],
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an enum value with a particular name and possible variants.

fn deserialize_identifier<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting the name of a struct field or the discriminant of an enum variant.

fn deserialize_ignored_any<V>(
    self,
    _visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored.

fn deserialize_i128<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an i128 value.

fn deserialize_u128<V>(
    self,
    visitor: V
) -> Result<<V as Visitor<'de>>::Value, Self::Error> where
    V: Visitor<'de>, 

Hint that the Deserialize type is expecting an u128 value.

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form.

impl From<Vec<u8, Global>> for Data

fn from(data: Vec<u8>) -> Self

Performs the conversion.

impl<K: Reader + Ord, V: Reader> Into<BTreeMap<K, V>> for Data

fn into(self) -> BTreeMap<K, V>

Performs the conversion.

impl<K: Reader + Eq + Hash, V: Reader> Into<HashMap<K, V, RandomState>> for Data

fn into(self) -> HashMap<K, V, RandomState>

Performs the conversion.

impl Into<String> for Data

fn into(self) -> String

Performs the conversion.

impl<T: ReadFrom + Reader + Dummy> Into<Vec<T, Global>> for Data

fn into(self) -> Vec<T>

Performs the conversion.

impl Into<Vec<u8, Global>> for Data

fn into(self) -> Vec<u8>

Performs the conversion.

impl Into<f32> for Data

fn into(self) -> f32

Performs the conversion.

impl Into<f64> for Data

fn into(self) -> f64

Performs the conversion.

impl Into<i128> for Data

fn into(self) -> i128

Performs the conversion.

impl Into<i16> for Data

fn into(self) -> i16

Performs the conversion.

impl Into<i32> for Data

fn into(self) -> i32

Performs the conversion.

impl Into<i64> for Data

fn into(self) -> i64

Performs the conversion.

impl Into<i8> for Data

fn into(self) -> i8

Performs the conversion.

impl Into<u128> for Data

fn into(self) -> u128

Performs the conversion.

impl Into<u16> for Data

fn into(self) -> u16

Performs the conversion.

impl Into<u32> for Data

fn into(self) -> u32

Performs the conversion.

impl Into<u64> for Data

fn into(self) -> u64

Performs the conversion.

impl Into<u8> for Data

fn into(self) -> u8

Performs the conversion.

impl<T: ReadFrom> ReadAs<T> for Data

fn read_as(&mut self) -> Result<T>

impl ReadFrom for Data

fn readfrom(data: &mut Data) -> Result<Self> where
    Self: Sized, 

impl<'a> Serializer for &'a mut Data

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.

type Error = DataError

The error type when some error occurs during serialization.

type SerializeSeq = DataSerializeSeq<'a>

Type returned from serialize_seq for serializing the content of the sequence.

type SerializeTuple = DataSerializeTuple<'a>

Type returned from serialize_tuple for serializing the content of the tuple.

type SerializeTupleStruct = DataSerializeTupleStruct<'a>

Type returned from serialize_tuple_struct for serializing the content of the tuple struct.

type SerializeTupleVariant = DataSerializeTupleVariant<'a>

Type returned from serialize_tuple_variant for serializing the content of the tuple variant.

type SerializeMap = DataSerializeMap<'a>

Type returned from serialize_map for serializing the content of the map.

type SerializeStruct = DataSerializeTupleStruct<'a>

Type returned from serialize_struct for serializing the content of the struct.

type SerializeStructVariant = DataSerializeTupleVariant<'a>

Type returned from serialize_struct_variant for serializing the content of the struct variant.

fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>

Serialize a bool value.

fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>

Serialize an i8 value.

fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>

Serialize an i16 value.

fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>

Serialize an i32 value.

fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>

Serialize an i64 value.

fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>

Serialize a u8 value.

fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>

Serialize a u16 value.

fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>

Serialize a u32 value.

fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>

Serialize a u64 value.

fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>

Serialize an f32 value.

fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>

Serialize an f64 value.

fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>

Serialize a character.

fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>

Serialize a &str.

fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>

Serialize a chunk of raw byte data.

fn serialize_none(self) -> Result<Self::Ok, Self::Error>

Serialize a None value.

fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> where
    T: Serialize, 

Serialize a Some(T) value.

fn serialize_unit(self) -> Result<Self::Ok, Self::Error>

Serialize a () value.

fn serialize_unit_struct(
    self,
    _name: &'static str
) -> Result<Self::Ok, Self::Error>

Serialize a unit struct like struct Unit or PhantomData<T>.

fn serialize_unit_variant(
    self,
    _name: &'static str,
    _variant_index: u32,
    variant: &'static str
) -> Result<Self::Ok, Self::Error>

Serialize a unit variant like E::A in enum E { A, B }.

fn serialize_newtype_struct<T: ?Sized>(
    self,
    _name: &'static str,
    value: &T
) -> Result<Self::Ok, Self::Error> where
    T: Serialize, 

Serialize a newtype struct like struct Millimeters(u8).

fn serialize_newtype_variant<T: ?Sized>(
    self,
    _name: &'static str,
    _variant_index: u32,
    variant: &'static str,
    value: &T
) -> Result<Self::Ok, Self::Error> where
    T: Serialize, 

Serialize a newtype variant like E::N in enum E { N(u8) }.

fn serialize_seq(
    self,
    len: Option<usize>
) -> Result<Self::SerializeSeq, Self::Error>

Begin to serialize a variably sized sequence. This call must be followed by zero or more calls to serialize_element, then a call to end.

fn serialize_tuple(
    self,
    len: usize
) -> Result<Self::SerializeTuple, Self::Error>

Begin to serialize a statically sized sequence whose length will be known at deserialization time without looking at the serialized data. This call must be followed by zero or more calls to serialize_element, then a call to end.

fn serialize_tuple_struct(
    self,
    _name: &'static str,
    len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>

Begin to serialize a tuple struct like struct Rgb(u8, u8, u8). This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_tuple_variant(
    self,
    _name: &'static str,
    _variant_index: u32,
    variant: &'static str,
    len: usize
) -> Result<Self::SerializeTupleVariant, Self::Error>

Begin to serialize a tuple variant like E::T in enum E { T(u8, u8) }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_map(
    self,
    len: Option<usize>
) -> Result<Self::SerializeMap, Self::Error>

Begin to serialize a map. This call must be followed by zero or more calls to serialize_key and serialize_value, then a call to end.

fn serialize_struct(
    self,
    _name: &'static str,
    len: usize
) -> Result<Self::SerializeStruct, Self::Error>

Begin to serialize a struct like struct Rgb { r: u8, g: u8, b: u8 }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_struct_variant(
    self,
    _name: &'static str,
    _variant_index: u32,
    variant: &'static str,
    len: usize
) -> Result<Self::SerializeStructVariant, Self::Error>

Begin to serialize a struct variant like E::S in enum E { S { r: u8, g: u8, b: u8 } }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> where
    T: Display, 

Serialize a string produced by an implementation of Display.

fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>

Serialize an i128 value.

fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>

Serialize a u128 value.

fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Serialize, 

Collect an iterator as a sequence.

fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
    K: Serialize,
    V: Serialize,
    I: IntoIterator<Item = (K, V)>, 

Collect an iterator as a map.

fn is_human_readable(&self) -> bool

Determine whether Serialize implementations should serialize in human-readable form.