[−][src]Trait serde_hex::SerHexSeq

pub trait SerHexSeq<C>: Sized + SerHex<Strict> + SerHex<StrictCap> where
    C: HexConf, {
    fn size() -> usize;

    fn serialize<'a, S, T>(
        sequence: T, 
        serializer: S
    ) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
        T: IntoIterator<Item = &'a Self>,
        Self: 'a,
    { ... }
    fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
    where
        D: Deserializer<'de>,
        T: FromIterator<Self>,
    { ... }
}

Variant of SerHex for serializing/deserializing sequence types as contiguous hexadecimal strings.

NOTE: Compact configurations are not compatible with this trait. The size of each element must be consistent in order to avoid ambiguous encoding.

#[derive(Debug,PartialEq,Eq,Serialize,Deserialize)]
struct Bytes(#[serde(with = "SerHexSeq::<StrictPfx>")] Vec<u8>);

let bytes: Bytes = serde_json::from_str(r#""0xdeadbeef""#).unwrap();
assert_eq!(bytes,Bytes(vec![0xde,0xad,0xbe,0xef]));

Required methods

`fn size() -> usize`

expected size (in bytes) of a single element. used to partition the hexadecimal string into individual elements.

Loading content...

Provided methods

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,`

Same as SerHex::serialize, but for sequences of Self.

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,`

Same as SerHex::deserialize, but for sequences of Self.

Loading content...

Implementations on Foreign Types

`impl SerHexSeq<Strict> for u8`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictPfx> for u8`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCap> for u8`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCapPfx> for u8`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<Strict> for u16`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictPfx> for u16`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCap> for u16`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCapPfx> for u16`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<Strict> for u32`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictPfx> for u32`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCap> for u32`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCapPfx> for u32`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<Strict> for u64`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictPfx> for u64`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCap> for u64`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCapPfx> for u64`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 2] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 2] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 2] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 2] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 3] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 3] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 3] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 3] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 4] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 4] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 4] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 4] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 5] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 5] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 5] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 5] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 6] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 6] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 6] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 6] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 7] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 7] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 7] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 7] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 8] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 8] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 8] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 8] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 9] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 9] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 9] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 9] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 10] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 10] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 10] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 10] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 11] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 11] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 11] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 11] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 12] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 12] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 12] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 12] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 13] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 13] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 13] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 13] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 14] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 14] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 14] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 14] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 15] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 15] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 15] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 15] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 16] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 16] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 16] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 16] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 17] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 17] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 17] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 17] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 18] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 18] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 18] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 18] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 19] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 19] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 19] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 19] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 20] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 20] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 20] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 20] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 21] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 21] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 21] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 21] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 22] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 22] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 22] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 22] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 23] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 23] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 23] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 23] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 24] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 24] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 24] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 24] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 25] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 25] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 25] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 25] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 26] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 26] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 26] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 26] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 27] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 27] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 27] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 27] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 28] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 28] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 28] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 28] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 29] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 29] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 29] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 29] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 30] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 30] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 30] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 30] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 31] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 31] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 31] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 31] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 32] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 32] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 32] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 32] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 33] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 33] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 33] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 33] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 34] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 34] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 34] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 34] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 35] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 35] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 35] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 35] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 36] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 36] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 36] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 36] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 37] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 37] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 37] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 37] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 38] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 38] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 38] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 38] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 39] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 39] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 39] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 39] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 40] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 40] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 40] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 40] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 41] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 41] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 41] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 41] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 42] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 42] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 42] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 42] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 43] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 43] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 43] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 43] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 44] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 44] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 44] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 44] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 45] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 45] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 45] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 45] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 46] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 46] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 46] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 46] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 47] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 47] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 47] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 47] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 48] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 48] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 48] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 48] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 49] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 49] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 49] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 49] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 50] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 50] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 50] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 50] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 51] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 51] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 51] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 51] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 52] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 52] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 52] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 52] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 53] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 53] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 53] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 53] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 54] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 54] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 54] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 54] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 55] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 55] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 55] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 55] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 56] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 56] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 56] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 56] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 57] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 57] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 57] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 57] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 58] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 58] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 58] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 58] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 59] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 59] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 59] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 59] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 60] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 60] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 60] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 60] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 61] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 61] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 61] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 61] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 62] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 62] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 62] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 62] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 63] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 63] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 63] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 63] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 64] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 64] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 64] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 64] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

Loading content...

Implementors

Loading content...

[−][src]Trait serde_hex::SerHexSeq

Required methods

fn size() -> usize

Provided methods

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,

Implementations on Foreign Types

impl SerHexSeq<Strict> for u8[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictPfx> for u8[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictCap> for u8[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictCapPfx> for u8[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<Strict> for u16[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictPfx> for u16[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictCap> for u16[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictCapPfx> for u16[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<Strict> for u32[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictPfx> for u32[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictCap> for u32[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictCapPfx> for u32[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<Strict> for u64[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictPfx> for u64[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictCap> for u64[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl SerHexSeq<StrictCapPfx> for u64[src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl<T, E> SerHexSeq<Strict> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>, [src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl<T, E> SerHexSeq<StrictPfx> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>, [src]

fn size() -> usize[src]

fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a, [src]

fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>, [src]

impl<T, E> SerHexSeq<StrictCap> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>, [src]

`fn size() -> usize`

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,`

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,`

`impl SerHexSeq<Strict> for u8`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictPfx> for u8`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCap> for u8`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCapPfx> for u8`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<Strict> for u16`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictPfx> for u16`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCap> for u16`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCapPfx> for u16`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<Strict> for u32`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictPfx> for u32`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCap> for u32`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCapPfx> for u32`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<Strict> for u64`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictPfx> for u64`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCap> for u64`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl SerHexSeq<StrictCapPfx> for u64`[src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<Strict> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictPfx> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<StrictPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCap> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<StrictCap> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]

`fn size() -> usize`[src]

`fn serialize<'a, S, T>(sequence: T, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, T: IntoIterator<Item = &'a Self>, Self: 'a,` [src]

`fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error> where D: Deserializer<'de>, T: FromIterator<Self>,` [src]

`impl<T, E> SerHexSeq<StrictCapPfx> for [T; 1] where E: From<Error> + Error, T: SerHexSeq<StrictCapPfx> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,` [src]