Trait Serialize

pub trait Serialize {
    // Required method
    fn serialize<S>(
        &self,
        serializer: S,
    ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> 
       where S: Serializer;
}

Available on crate feature dep_serde only.

A data structure that can be serialized into any data format supported by Serde.

Serde provides Serialize implementations for many Rust primitive and standard library types. The complete list is here. All of these can be serialized using Serde out of the box.

Additionally, Serde provides a procedural macro called serde_derive to automatically generate Serialize implementations for structs and enums in your program. See the derive section of the manual for how to use this.

In rare cases it may be necessary to implement Serialize manually for some type in your program. See the Implementing Serialize section of the manual for more about this.

Third-party crates may provide Serialize implementations for types that they expose. For example the linked-hash-map crate provides a LinkedHashMap<K, V> type that is serializable by Serde because the crate provides an implementation of Serialize for it.

Required Methods

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

See the Implementing Serialize section of the manual for more information about how to implement this method.

use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Person {
    name: String,
    age: u8,
    phones: Vec<String>,
}

// This is what #[derive(Serialize)] would generate.
impl Serialize for Person {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_struct("Person", 3)?;
        s.serialize_field("name", &self.name)?;
        s.serialize_field("age", &self.age)?;
        s.serialize_field("phones", &self.phones)?;
        s.end()
    }
}

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.

Implementations on Foreign Types

impl Serialize for bool

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for char

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for f32

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for f64

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i8

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i16

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i32

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i64

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i128

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for isize

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for str

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u8

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u16

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u32

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u64

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u128

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for ()

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for usize

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl Serialize for EvCode

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

where __S: Serializer,

impl<'a, T> Serialize for &'a T

where T: Serialize + ?Sized,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<'a, T> Serialize for &'a mut T

where T: Serialize + ?Sized,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1> Serialize for (T0, T1)

where T0: Serialize, T1: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2> Serialize for (T0, T1, T2)

where T0: Serialize, T1: Serialize, T2: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4> Serialize for (T0, T1, T2, T3, T4)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5> Serialize for (T0, T1, T2, T3, T4, T5)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6> Serialize for (T0, T1, T2, T3, T4, T5, T6)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize, T12: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize, T12: Serialize, T13: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize, T12: Serialize, T13: Serialize, T14: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize, T12: Serialize, T13: Serialize, T14: Serialize, T15: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 0]

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 1]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 2]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 3]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 4]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 5]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 6]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 7]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 8]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 9]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 10]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 11]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 12]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 13]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 14]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 15]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 16]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 17]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 18]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 19]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 20]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 21]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 22]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 23]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 24]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 25]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 26]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 27]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 28]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 29]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 30]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 31]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 32]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T]

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for (T,)

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for Spanned<T>

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Implementors

impl Serialize for IpAddr

impl Serialize for SocketAddr

impl Serialize for Axis

impl Serialize for Button

impl Serialize for EventType

impl Serialize for AxisOrBtn

impl Serialize for ClockSpeed

impl Serialize for DistortionKind

impl Serialize for EqFilterKind

impl Serialize for FilterMode

impl Serialize for Easing

impl Serialize for Waveform

impl Serialize for EndPosition

impl Serialize for PlaybackPosition

impl Serialize for PlaybackState

impl Serialize for TrackPlaybackState

impl Serialize for devela::_core::sync::atomic::AtomicBool

impl Serialize for devela::_core::sync::atomic::AtomicI8

impl Serialize for devela::_core::sync::atomic::AtomicI16

impl Serialize for devela::_core::sync::atomic::AtomicI32

impl Serialize for devela::_core::sync::atomic::AtomicI64

impl Serialize for devela::_core::sync::atomic::AtomicIsize

impl Serialize for devela::_core::sync::atomic::AtomicU8

impl Serialize for devela::_core::sync::atomic::AtomicU16

impl Serialize for devela::_core::sync::atomic::AtomicU32

impl Serialize for devela::_core::sync::atomic::AtomicU64

impl Serialize for devela::_core::sync::atomic::AtomicUsize

impl Serialize for devela::all::AtomicBool

impl Serialize for AtomicF32

impl Serialize for AtomicF64

impl Serialize for devela::all::AtomicI8

impl Serialize for devela::all::AtomicI16

impl Serialize for devela::all::AtomicI32

impl Serialize for devela::all::AtomicI64

impl Serialize for AtomicI128

impl Serialize for devela::all::AtomicIsize

impl Serialize for devela::all::AtomicU8

impl Serialize for devela::all::AtomicU16

impl Serialize for devela::all::AtomicU32

impl Serialize for devela::all::AtomicU64

impl Serialize for AtomicU128

impl Serialize for devela::all::AtomicUsize

impl Serialize for CStr

impl Serialize for CString

impl Serialize for Duration

impl Serialize for Ipv4Addr

impl Serialize for Ipv6Addr

impl Serialize for NonZero<i8>

impl Serialize for NonZero<i16>

impl Serialize for NonZero<i32>

impl Serialize for NonZero<i64>

impl Serialize for NonZero<i128>

impl Serialize for NonZero<isize>

impl Serialize for NonZero<u8>

impl Serialize for NonZero<u16>

impl Serialize for NonZero<u32>

impl Serialize for NonZero<u64>

impl Serialize for NonZero<u128>

impl Serialize for NonZero<usize>

impl Serialize for OsStr

impl Serialize for OsString

impl Serialize for Path

impl Serialize for PathBuf

impl Serialize for SocketAddrV4

impl Serialize for SocketAddrV6

impl Serialize for String

impl Serialize for SystemTime

impl Serialize for Code

impl Serialize for Event

impl Serialize for GamepadId

impl Serialize for Region

impl Serialize for Capacities

impl Serialize for Decibels

impl Serialize for Frame

impl Serialize for Mix

impl Serialize for Panning

impl Serialize for PlaybackRate

impl Serialize for Semitones

impl Serialize for devela::_dep::orion::aead::streaming::Nonce

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::auth::Tag

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hash::Digest

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::aead::chacha20poly1305::Nonce

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::hash::sha2::sha256::Digest

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::hash::sha2::sha384::Digest

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::hash::sha2::sha512::Digest

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::hash::sha3::sha3_224::Digest

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::hash::sha3::sha3_256::Digest

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::hash::sha3::sha3_384::Digest

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::hash::sha3::sha3_512::Digest

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::kem::mlkem512::Ciphertext

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::kem::mlkem768::Ciphertext

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::kem::mlkem1024::Ciphertext

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::kem::xwing::Ciphertext

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for EncapsulationKey

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::mac::hmac::sha256::Tag

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::mac::hmac::sha384::Tag

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::mac::hmac::sha512::Tag

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for devela::_dep::orion::hazardous::mac::poly1305::Tag

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for Salt

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for PublicKey

This type tries to serialize as a &[u8] would. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for PasswordHash

PasswordHash serializes as would a String. Note that the serialized type likely does not have the same protections that Orion provides, such as constant-time operations. A good rule of thumb is to only serialize these types for storage. Don’t operate on the serialized types.

impl Serialize for Date

impl Serialize for Datetime

impl Serialize for InternalString

impl Serialize for Time

impl Serialize for f32x4

impl Serialize for f32x8

impl Serialize for f64x2

impl Serialize for f64x4

impl Serialize for i8x16

impl Serialize for i8x32

impl Serialize for i16x8

impl Serialize for i16x16

impl Serialize for i32x4

impl Serialize for i32x8

impl Serialize for i64x2

impl Serialize for i64x4

impl Serialize for u8x16

impl Serialize for u16x8

impl Serialize for u16x16

impl Serialize for u32x4

impl Serialize for u32x8

impl Serialize for u64x2

impl Serialize for u64x4

impl<'a> Serialize for Arguments<'a>

impl<'a, T> Serialize for Cow<'a, T>

where T: Serialize + ToOwned + ?Sized,

impl<'a, T> Serialize for devela::_dep::bumpalo::boxed::Box<'a, T>

where T: Serialize,

impl<'a, T> Serialize for devela::_dep::bumpalo::collections::Vec<'a, T>

where T: Serialize,

impl<Idx> Serialize for Range<Idx>

where Idx: Serialize,

impl<Idx> Serialize for RangeFrom<Idx>

where Idx: Serialize,

impl<Idx> Serialize for RangeInclusive<Idx>

where Idx: Serialize,

impl<Idx> Serialize for RangeTo<Idx>

where Idx: Serialize,

impl<K, V> Serialize for BTreeMap<K, V>

where K: Serialize, V: Serialize,

impl<K, V, H> Serialize for HashMap<K, V, H>

where K: Serialize, V: Serialize,

impl<T> Serialize for Option<T>

where T: Serialize,

impl<T> Serialize for Bound<T>

where T: Serialize,

impl<T> Serialize for BTreeSet<T>

where T: Serialize,

impl<T> Serialize for BinaryHeap<T>

where T: Serialize,

impl<T> Serialize for devela::all::Box<T>

where T: Serialize + ?Sized,

impl<T> Serialize for Cell<T>

where T: Serialize + Copy,

impl<T> Serialize for LinkedList<T>

where T: Serialize,

impl<T> Serialize for Mutex<T>

where T: Serialize + ?Sized,

impl<T> Serialize for PhantomData<T>

where T: ?Sized,

impl<T> Serialize for RefCell<T>

where T: Serialize + ?Sized,

impl<T> Serialize for Reverse<T>

where T: Serialize,

impl<T> Serialize for RwLock<T>

where T: Serialize + ?Sized,

impl<T> Serialize for Saturating<T>

where T: Serialize,

impl<T> Serialize for devela::all::Vec<T>

where T: Serialize,

impl<T> Serialize for VecDeque<T>

where T: Serialize,

impl<T> Serialize for Wrapping<T>

where T: Serialize,

impl<T> Serialize for Mapping<T>

where T: Serialize,

impl<T, E> Serialize for Result<T, E>

where T: Serialize, E: Serialize,

impl<T, H> Serialize for HashSet<T, H>

where T: Serialize,