[−][src]Trait serde_hex::SerHex
Trait specifying custom serialization and deserialization logic from a
hexadecimal string to some arbitrary type. This trait can be used to apply
custom parsing when using serde's #[derive(Serialize,Deserialize)]
flag. Just add #[serde(with = "SerHex")]
above any fields which implement
this trait. Simplistic default implimentations for the the serialize
and
deserialize
methods are provided based on into_hex_raw
and from_hex_raw
respectively.
Associated Types
type Error: Error
Error type of the implementation.
Unless you have a compelling reason to do so, it is best to use the error
type exposed by serde-hex
, since this is the error used for most provided
implementations (the generic array impls will work with any error that
implements From
for the serde-hex
error type).
Required methods
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
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]>,
S: AsRef<[u8]>,
Attempt to parse some buffer of hexadecimal bytes into an instance of Self
.
Provided methods
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]>,
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,
S: Serializer,
Attempt to serialize self
into a hexadecimal string representation.
NOTE: The default implementation attempts to avoid heap-allocation with a
SmallVec
of size [u8;64]
. This default will
prevent heap-alloc for non-prefixed serializations of [u8;32]
or smaller.
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
D: Deserializer<'de>,
Attempt to deserialize a hexadecimal string into an instance of Self
.
Implementations on Foreign Types
impl<C> SerHex<C> for u8 where
C: HexConf,
[src]
C: HexConf,
type Error = Error
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<C> SerHex<C> for u16 where
C: HexConf,
[src]
C: HexConf,
type Error = Error
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<C> SerHex<C> for u32 where
C: HexConf,
[src]
C: HexConf,
type Error = Error
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<C> SerHex<C> for u64 where
C: HexConf,
[src]
C: HexConf,
type Error = Error
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 1] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 2] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 3] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 4] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 5] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 6] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 7] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 8] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 9] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 10] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 11] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 12] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 13] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 14] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 15] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 16] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 17] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 18] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 19] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 20] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 21] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 22] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 23] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 24] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 25] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 26] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 27] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 28] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 29] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 30] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 31] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 32] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 33] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 34] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 35] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 36] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 37] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 38] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 39] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 40] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 41] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 42] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 43] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 44] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 45] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 46] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 47] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 48] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 49] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 50] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 51] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 52] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 53] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 54] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 55] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 56] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 57] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 58] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 59] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 60] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 61] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 62] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 63] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictPfx> for [T; 64] where
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCap> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T, E> SerHex<StrictCapPfx> 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>,
[src]
E: From<Error> + Error,
T: SerHex<Strict, Error = E> + SerHex<StrictPfx, Error = E> + SerHex<StrictCap, Error = E> + SerHex<StrictCapPfx, Error = E>,
type Error = E
fn into_hex_raw<D>(&self, dst: D) -> Result<(), Self::Error> where
D: Write,
[src]
D: Write,
fn from_hex_raw<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn into_hex(&self) -> Result<String, Self::Error>
[src]
fn from_hex<S>(src: S) -> Result<Self, Self::Error> where
S: AsRef<[u8]>,
[src]
S: AsRef<[u8]>,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
fn deserialize<'de, D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,