Struct Strict

pub struct Strict;

Config indicating a strict representation with no capiltaization and no prefixing.

Trait Implementations

impl HexConf for Strict

fn compact() -> bool

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

fn withpfx() -> bool

function indicating whether to prefixing (0x).

fn withcap() -> bool

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

impl<T, E> SerHex<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<Strict> 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<T, E> SerHex<Strict> 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<Strict> 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<Strict> 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> SerHexSeq<Strict> for [T; 1]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 10]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 11]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 12]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 13]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 14]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 15]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 16]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 17]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 18]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 19]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 2]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 20]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 21]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 22]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 23]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 24]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 25]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 26]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 27]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 28]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 29]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 3]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 30]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 31]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 32]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 33]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 34]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 35]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 36]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 37]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 38]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 39]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 4]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 40]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 41]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 42]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 43]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 44]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 45]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 46]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 47]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 48]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 49]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 5]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 50]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 51]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 52]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 53]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 54]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 55]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 56]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 57]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 58]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 59]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 6]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 60]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 61]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 62]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 63]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 64]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 7]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 8]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> for [T; 9]

where E: From<Error> + Error, T: SerHexSeq<Strict> + SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,

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<Strict> 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<Strict> 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<Strict> 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 SerHexSeq<Strict> 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.