Struct serde_hex::config::StrictPfx

pub struct StrictPfx;

Config indicating a strict representation with prefixing but no capitalization.

Trait Implementations

impl HexConf for StrictPfx

fn withpfx() -> bool

function indicating whether to prefixing (0x).

fn compact() -> bool

function indicating whether to use compact (as apposed to strict) representation.

fn withcap() -> bool

function indicating whether to use capital letters (A-F).

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

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

type Error = E

Error type of the implementation.

fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
    D: Write, 

Attept to convert self to hexadecimal, writing the resultant bytes to some buffer.

fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to parse some buffer of hexadecimal bytes into an instance of Self.

fn into_hex(&self) -> Result<String, Self::Error>

Attempt to convert self into a hexadecimal string representation.

fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
    S: AsRef<[u8]>, 

Attempt to convert a slice of hexadecimal bytes into an instance of Self.

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

Attempt to serialize self into a hexadecimal string representation.

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

Attempt to deserialize a hexadecimal string into an instance of Self.

impl SerHexSeq<StrictPfx> for u8

fn size() -> usize

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

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.

impl SerHexSeq<StrictPfx> for u16

fn size() -> usize

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

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.

impl SerHexSeq<StrictPfx> for u32

fn size() -> usize

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

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.

impl SerHexSeq<StrictPfx> for u64

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.

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>, 

fn size() -> usize

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

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.