messagepack_rs::serializable

Trait Serializable

Source 
pub trait Serializable: Sized {

Show 19 methods    // Required method
    fn serialize(self) -> Result<Vec<u8>, SerializeError>;

    // Provided methods
    fn serialize_nil() -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_bool(v: bool) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_float32(v: f32) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_float64(v: f64) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_uint8(v: u8) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_uint16(v: u16) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_uint32(v: u32) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_uint64(v: u64) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_int8(v: i8) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_int16(v: i16) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_int32(v: i32) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_int64(v: i64) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_binary(v: Binary) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_string(v: String) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_array(v: Vec<Self>) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_map(
        v: BTreeMap<String, Self>,
    ) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_extension(v: Extension) -> Result<Vec<u8>, SerializeError> { ... }
    fn serialize_timestamp(v: DateTime<Utc>) -> Result<Vec<u8>, SerializeError> { ... }

}

Required Methods§

Source

fn serialize(self) -> Result<Vec<u8>, SerializeError>

Provided Methods§

Source

fn serialize_nil() -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 52)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_bool(v: bool) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 53)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_float32(v: f32) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 54)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_float64(v: f64) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 55)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_uint8(v: u8) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 56)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_uint16(v: u16) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 57)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_uint32(v: u32) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 58)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_uint64(v: u64) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 59)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_int8(v: i8) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 60)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_int16(v: i16) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 61)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_int32(v: i32) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 62)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_int64(v: i64) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 63)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_binary(v: Binary) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 64)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_string(v: String) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 65)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_array(v: Vec<Self>) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 66)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_map(v: BTreeMap<String, Self>) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 67)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_extension(v: Extension) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 68)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }
Source

fn serialize_timestamp(v: DateTime<Utc>) -> Result<Vec<u8>, SerializeError>

Examples found in repository?
examples/extension2.rs (line 69)
50    fn serialize(self) -> Result<Vec<u8>, SerializeError> {
51        match self {
52            Self::Nil => Self::serialize_nil(),
53            Self::Bool(v) => Self::serialize_bool(v),
54            Self::Float32(v) => Self::serialize_float32(v),
55            Self::Float64(v) => Self::serialize_float64(v),
56            Self::UInt8(v) => Self::serialize_uint8(v),
57            Self::UInt16(v) => Self::serialize_uint16(v),
58            Self::UInt32(v) => Self::serialize_uint32(v),
59            Self::UInt64(v) => Self::serialize_uint64(v),
60            Self::Int8(v) => Self::serialize_int8(v),
61            Self::Int16(v) => Self::serialize_int16(v),
62            Self::Int32(v) => Self::serialize_int32(v),
63            Self::Int64(v) => Self::serialize_int64(v),
64            Self::Binary(v) => Self::serialize_binary(v),
65            Self::String(v) => Self::serialize_string(v),
66            Self::Array(v) => Self::serialize_array(v),
67            Self::Map(v) => Self::serialize_map(v),
68            Self::Extension(v) => Self::serialize_extension(v),
69            Self::Timestamp(v) => Self::serialize_timestamp(v),
70            Self::Rgba(v) => {
71                let mut w = Vec::with_capacity(1 + 1 + 4);
72                w.write_u8(Marker::FixExt4.into()).or(Err(SerializeError::FailedToWrite))?;
73                w.write_i8(0).or(Err(SerializeError::FailedToWrite))?;
74                w.write_u8(v.r).or(Err(SerializeError::FailedToWrite))?;
75                w.write_u8(v.g).or(Err(SerializeError::FailedToWrite))?;
76                w.write_u8(v.b).or(Err(SerializeError::FailedToWrite))?;
77                w.write_u8(v.a).or(Err(SerializeError::FailedToWrite))?;
78                Ok(w)
79            },
80        }
81    }

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§