use crate::core::hash::{DefaultHashable, Hash, Hashed};
use crate::global::PROTOCOL_VERSION;
use byteorder::{BigEndian, ByteOrder, ReadBytesExt};
use keychain::{BlindingFactor, Identifier, IDENTIFIER_SIZE};
use std::convert::TryInto;
use std::fmt::{self, Debug};
use std::io::{self, Read, Write};
use std::{cmp, error, marker};
use util::secp::constants::{
AGG_SIGNATURE_SIZE, COMPRESSED_PUBLIC_KEY_SIZE, MAX_PROOF_SIZE, PEDERSEN_COMMITMENT_SIZE,
SECRET_KEY_SIZE,
};
use util::secp::key::PublicKey;
use util::secp::pedersen::{Commitment, RangeProof};
use util::secp::Signature;
use util::secp::{ContextFlag, Secp256k1};
#[derive(Clone, Eq, PartialEq, Debug, Serialize, Deserialize)]
pub enum Error {
IOErr(
String,
#[serde(
serialize_with = "serialize_error_kind",
deserialize_with = "deserialize_error_kind"
)]
io::ErrorKind,
),
UnexpectedData {
expected: Vec<u8>,
received: Vec<u8>,
},
CorruptedData,
CountError,
TooLargeReadErr,
HexError(String),
SortError,
DuplicateError,
InvalidBlockVersion,
UnsupportedProtocolVersion,
}
impl From<io::Error> for Error {
fn from(e: io::Error) -> Error {
Error::IOErr(format!("{}", e), e.kind())
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Error::IOErr(ref e, ref _k) => write!(f, "{}", e),
Error::UnexpectedData {
expected: ref e,
received: ref r,
} => write!(f, "expected {:?}, got {:?}", e, r),
Error::CorruptedData => f.write_str("corrupted data"),
Error::CountError => f.write_str("count error"),
Error::SortError => f.write_str("sort order"),
Error::DuplicateError => f.write_str("duplicate"),
Error::TooLargeReadErr => f.write_str("too large read"),
Error::HexError(ref e) => write!(f, "hex error {:?}", e),
Error::InvalidBlockVersion => f.write_str("invalid block version"),
Error::UnsupportedProtocolVersion => f.write_str("unsupported protocol version"),
}
}
}
impl error::Error for Error {
fn cause(&self) -> Option<&dyn error::Error> {
match *self {
Error::IOErr(ref _e, ref _k) => Some(self),
_ => None,
}
}
fn description(&self) -> &str {
match *self {
Error::IOErr(ref e, _) => e,
Error::UnexpectedData { .. } => "unexpected data",
Error::CorruptedData => "corrupted data",
Error::CountError => "count error",
Error::SortError => "sort order",
Error::DuplicateError => "duplicate error",
Error::TooLargeReadErr => "too large read",
Error::HexError(_) => "hex error",
Error::InvalidBlockVersion => "invalid block version",
Error::UnsupportedProtocolVersion => "unsupported protocol version",
}
}
}
#[derive(Copy, Clone, PartialEq, Eq)]
pub enum SerializationMode {
Full,
Hash,
}
impl SerializationMode {
pub fn is_hash_mode(&self) -> bool {
match self {
SerializationMode::Hash => true,
_ => false,
}
}
}
pub trait Writer {
fn serialization_mode(&self) -> SerializationMode;
fn protocol_version(&self) -> ProtocolVersion;
fn write_u8(&mut self, n: u8) -> Result<(), Error> {
self.write_fixed_bytes(&[n])
}
fn write_u16(&mut self, n: u16) -> Result<(), Error> {
let mut bytes = [0; 2];
BigEndian::write_u16(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_u32(&mut self, n: u32) -> Result<(), Error> {
let mut bytes = [0; 4];
BigEndian::write_u32(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_i32(&mut self, n: i32) -> Result<(), Error> {
let mut bytes = [0; 4];
BigEndian::write_i32(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_u64(&mut self, n: u64) -> Result<(), Error> {
let mut bytes = [0; 8];
BigEndian::write_u64(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_i64(&mut self, n: i64) -> Result<(), Error> {
let mut bytes = [0; 8];
BigEndian::write_i64(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_bytes<T: AsRef<[u8]>>(&mut self, bytes: T) -> Result<(), Error> {
self.write_u64(bytes.as_ref().len() as u64)?;
self.write_fixed_bytes(bytes)
}
fn write_fixed_bytes<T: AsRef<[u8]>>(&mut self, bytes: T) -> Result<(), Error>;
fn write_empty_bytes(&mut self, length: usize) -> Result<(), Error> {
self.write_fixed_bytes(vec![0u8; length])
}
}
pub trait Reader {
fn read_u8(&mut self) -> Result<u8, Error>;
fn read_u16(&mut self) -> Result<u16, Error>;
fn read_u32(&mut self) -> Result<u32, Error>;
fn read_u64(&mut self) -> Result<u64, Error>;
fn read_i32(&mut self) -> Result<i32, Error>;
fn read_i64(&mut self) -> Result<i64, Error>;
fn read_bytes_len_prefix(&mut self) -> Result<Vec<u8>, Error>;
fn read_fixed_bytes(&mut self, length: usize) -> Result<Vec<u8>, Error>;
fn expect_u8(&mut self, val: u8) -> Result<u8, Error>;
fn protocol_version(&self) -> ProtocolVersion;
fn read_empty_bytes(&mut self, length: usize) -> Result<(), Error> {
for _ in 0..length {
if self.read_u8()? != 0u8 {
return Err(Error::CorruptedData);
}
}
Ok(())
}
}
pub trait Writeable {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error>;
}
pub struct IteratingReader<'a, T, R: Reader> {
count: u64,
curr: u64,
reader: &'a mut R,
_marker: marker::PhantomData<T>,
}
impl<'a, T, R: Reader> IteratingReader<'a, T, R> {
pub fn new(reader: &'a mut R, count: u64) -> Self {
let curr = 0;
IteratingReader {
count,
curr,
reader,
_marker: marker::PhantomData,
}
}
}
impl<'a, T, R> Iterator for IteratingReader<'a, T, R>
where
T: Readable,
R: Reader,
{
type Item = T;
fn next(&mut self) -> Option<T> {
if self.curr >= self.count {
return None;
}
self.curr += 1;
T::read(self.reader).ok()
}
}
pub fn read_multi<T, R>(reader: &mut R, count: u64) -> Result<Vec<T>, Error>
where
T: Readable,
R: Reader,
{
if count > 1_000_000 {
return Err(Error::TooLargeReadErr);
}
let res: Vec<T> = IteratingReader::new(reader, count).collect();
if res.len() as u64 != count {
return Err(Error::CountError);
}
Ok(res)
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, Ord, PartialOrd, PartialEq, Serialize)]
pub struct ProtocolVersion(pub u32);
impl ProtocolVersion {
pub const MAX: u32 = std::u32::MAX;
pub fn value(self) -> u32 {
self.0
}
pub fn local() -> ProtocolVersion {
PROTOCOL_VERSION
}
pub fn local_db() -> ProtocolVersion {
ProtocolVersion(1)
}
}
impl fmt::Display for ProtocolVersion {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl From<ProtocolVersion> for u32 {
fn from(v: ProtocolVersion) -> u32 {
v.0
}
}
impl Writeable for ProtocolVersion {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_u32(self.0)
}
}
impl Readable for ProtocolVersion {
fn read<R: Reader>(reader: &mut R) -> Result<ProtocolVersion, Error> {
let version = reader.read_u32()?;
Ok(ProtocolVersion(version))
}
}
pub trait Readable
where
Self: Sized,
{
fn read<R: Reader>(reader: &mut R) -> Result<Self, Error>;
}
pub fn deserialize<T: Readable, R: Read>(
source: &mut R,
version: ProtocolVersion,
) -> Result<T, Error> {
let mut reader = BinReader::new(source, version);
T::read(&mut reader)
}
pub fn deserialize_default<T: Readable, R: Read>(source: &mut R) -> Result<T, Error> {
deserialize(source, ProtocolVersion::local())
}
pub fn serialize<W: Writeable>(
sink: &mut dyn Write,
version: ProtocolVersion,
thing: &W,
) -> Result<(), Error> {
let mut writer = BinWriter::new(sink, version);
thing.write(&mut writer)
}
pub fn serialize_default<W: Writeable>(sink: &mut dyn Write, thing: &W) -> Result<(), Error> {
serialize(sink, ProtocolVersion::local(), thing)
}
pub fn ser_vec<W: Writeable>(thing: &W, version: ProtocolVersion) -> Result<Vec<u8>, Error> {
let mut vec = vec![];
serialize(&mut vec, version, thing)?;
Ok(vec)
}
pub struct BinReader<'a, R: Read> {
source: &'a mut R,
version: ProtocolVersion,
}
impl<'a, R: Read> BinReader<'a, R> {
pub fn new(source: &'a mut R, version: ProtocolVersion) -> Self {
BinReader { source, version }
}
}
fn map_io_err(err: io::Error) -> Error {
Error::IOErr(format!("{}", err), err.kind())
}
impl<'a, R: Read> Reader for BinReader<'a, R> {
fn read_u8(&mut self) -> Result<u8, Error> {
self.source.read_u8().map_err(map_io_err)
}
fn read_u16(&mut self) -> Result<u16, Error> {
self.source.read_u16::<BigEndian>().map_err(map_io_err)
}
fn read_u32(&mut self) -> Result<u32, Error> {
self.source.read_u32::<BigEndian>().map_err(map_io_err)
}
fn read_i32(&mut self) -> Result<i32, Error> {
self.source.read_i32::<BigEndian>().map_err(map_io_err)
}
fn read_u64(&mut self) -> Result<u64, Error> {
self.source.read_u64::<BigEndian>().map_err(map_io_err)
}
fn read_i64(&mut self) -> Result<i64, Error> {
self.source.read_i64::<BigEndian>().map_err(map_io_err)
}
fn read_bytes_len_prefix(&mut self) -> Result<Vec<u8>, Error> {
let len = self.read_u64()?;
self.read_fixed_bytes(len as usize)
}
fn read_fixed_bytes(&mut self, len: usize) -> Result<Vec<u8>, Error> {
if len > 100_000 {
return Err(Error::TooLargeReadErr);
}
let mut buf = vec![0; len];
self.source
.read_exact(&mut buf)
.map(move |_| buf)
.map_err(map_io_err)
}
fn expect_u8(&mut self, val: u8) -> Result<u8, Error> {
let b = self.read_u8()?;
if b == val {
Ok(b)
} else {
Err(Error::UnexpectedData {
expected: vec![val],
received: vec![b],
})
}
}
fn protocol_version(&self) -> ProtocolVersion {
self.version
}
}
pub struct StreamingReader<'a> {
total_bytes_read: u64,
version: ProtocolVersion,
stream: &'a mut dyn Read,
}
impl<'a> StreamingReader<'a> {
pub fn new(stream: &'a mut dyn Read, version: ProtocolVersion) -> StreamingReader<'a> {
StreamingReader {
total_bytes_read: 0,
version,
stream,
}
}
pub fn total_bytes_read(&self) -> u64 {
self.total_bytes_read
}
}
impl<'a> Reader for StreamingReader<'a> {
fn read_u8(&mut self) -> Result<u8, Error> {
let buf = self.read_fixed_bytes(1)?;
Ok(buf[0])
}
fn read_u16(&mut self) -> Result<u16, Error> {
let buf = self.read_fixed_bytes(2)?;
Ok(BigEndian::read_u16(&buf[..]))
}
fn read_u32(&mut self) -> Result<u32, Error> {
let buf = self.read_fixed_bytes(4)?;
Ok(BigEndian::read_u32(&buf[..]))
}
fn read_i32(&mut self) -> Result<i32, Error> {
let buf = self.read_fixed_bytes(4)?;
Ok(BigEndian::read_i32(&buf[..]))
}
fn read_u64(&mut self) -> Result<u64, Error> {
let buf = self.read_fixed_bytes(8)?;
Ok(BigEndian::read_u64(&buf[..]))
}
fn read_i64(&mut self) -> Result<i64, Error> {
let buf = self.read_fixed_bytes(8)?;
Ok(BigEndian::read_i64(&buf[..]))
}
fn read_bytes_len_prefix(&mut self) -> Result<Vec<u8>, Error> {
let len = self.read_u64()?;
self.total_bytes_read += 8;
self.read_fixed_bytes(len as usize)
}
fn read_fixed_bytes(&mut self, len: usize) -> Result<Vec<u8>, Error> {
let mut buf = vec![0u8; len];
self.stream.read_exact(&mut buf)?;
self.total_bytes_read += len as u64;
Ok(buf)
}
fn expect_u8(&mut self, val: u8) -> Result<u8, Error> {
let b = self.read_u8()?;
if b == val {
Ok(b)
} else {
Err(Error::UnexpectedData {
expected: vec![val],
received: vec![b],
})
}
}
fn protocol_version(&self) -> ProtocolVersion {
self.version
}
}
impl Readable for Commitment {
fn read<R: Reader>(reader: &mut R) -> Result<Commitment, Error> {
let a = reader.read_fixed_bytes(PEDERSEN_COMMITMENT_SIZE)?;
let mut c = [0; PEDERSEN_COMMITMENT_SIZE];
c[..PEDERSEN_COMMITMENT_SIZE].clone_from_slice(&a[..PEDERSEN_COMMITMENT_SIZE]);
Ok(Commitment(c))
}
}
impl Writeable for Commitment {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_fixed_bytes(self)
}
}
impl Writeable for BlindingFactor {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_fixed_bytes(self)
}
}
impl Readable for BlindingFactor {
fn read<R: Reader>(reader: &mut R) -> Result<BlindingFactor, Error> {
let bytes = reader.read_fixed_bytes(SECRET_KEY_SIZE)?;
Ok(BlindingFactor::from_slice(&bytes))
}
}
impl Writeable for Identifier {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_fixed_bytes(self)
}
}
impl Readable for Identifier {
fn read<R: Reader>(reader: &mut R) -> Result<Identifier, Error> {
let bytes = reader.read_fixed_bytes(IDENTIFIER_SIZE)?;
Ok(Identifier::from_bytes(&bytes))
}
}
impl Writeable for RangeProof {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_bytes(self)
}
}
impl Readable for RangeProof {
fn read<R: Reader>(reader: &mut R) -> Result<RangeProof, Error> {
let len = reader.read_u64()?;
let max_len = cmp::min(len as usize, MAX_PROOF_SIZE);
let p = reader.read_fixed_bytes(max_len)?;
let mut proof = [0; MAX_PROOF_SIZE];
proof[..p.len()].clone_from_slice(&p[..]);
Ok(RangeProof {
plen: proof.len(),
proof,
})
}
}
impl PMMRable for RangeProof {
type E = Self;
fn as_elmt(&self) -> Self::E {
*self
}
fn elmt_size() -> Option<u16> {
Some((8 + MAX_PROOF_SIZE).try_into().unwrap())
}
}
impl Readable for Signature {
fn read<R: Reader>(reader: &mut R) -> Result<Signature, Error> {
let a = reader.read_fixed_bytes(AGG_SIGNATURE_SIZE)?;
let mut c = [0; AGG_SIGNATURE_SIZE];
c[..AGG_SIGNATURE_SIZE].clone_from_slice(&a[..AGG_SIGNATURE_SIZE]);
Ok(Signature::from_raw_data(&c).unwrap())
}
}
impl Writeable for Signature {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_fixed_bytes(self)
}
}
impl Writeable for PublicKey {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
let secp = Secp256k1::with_caps(ContextFlag::None);
writer.write_fixed_bytes(self.serialize_vec(&secp, true))?;
Ok(())
}
}
impl Readable for PublicKey {
fn read<R: Reader>(reader: &mut R) -> Result<Self, Error> {
let buf = reader.read_fixed_bytes(COMPRESSED_PUBLIC_KEY_SIZE)?;
let secp = Secp256k1::with_caps(ContextFlag::None);
let pk = PublicKey::from_slice(&secp, &buf).map_err(|_| Error::CorruptedData)?;
Ok(pk)
}
}
pub trait VerifySortedAndUnique<T> {
fn verify_sorted_and_unique(&self) -> Result<(), Error>;
}
impl<T: Ord> VerifySortedAndUnique<T> for Vec<T> {
fn verify_sorted_and_unique(&self) -> Result<(), Error> {
for pair in self.windows(2) {
if pair[0] > pair[1] {
return Err(Error::SortError);
} else if pair[0] == pair[1] {
return Err(Error::DuplicateError);
}
}
Ok(())
}
}
pub struct BinWriter<'a> {
sink: &'a mut dyn Write,
version: ProtocolVersion,
}
impl<'a> BinWriter<'a> {
pub fn new(sink: &'a mut dyn Write, version: ProtocolVersion) -> BinWriter<'a> {
BinWriter { sink, version }
}
pub fn default(sink: &'a mut dyn Write) -> BinWriter<'a> {
BinWriter::new(sink, ProtocolVersion::local())
}
}
impl<'a> Writer for BinWriter<'a> {
fn serialization_mode(&self) -> SerializationMode {
SerializationMode::Full
}
fn write_fixed_bytes<T: AsRef<[u8]>>(&mut self, bytes: T) -> Result<(), Error> {
self.sink.write_all(bytes.as_ref())?;
Ok(())
}
fn protocol_version(&self) -> ProtocolVersion {
self.version
}
}
macro_rules! impl_int {
($int:ty, $w_fn:ident, $r_fn:ident) => {
impl Writeable for $int {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.$w_fn(*self)
}
}
impl Readable for $int {
fn read<R: Reader>(reader: &mut R) -> Result<$int, Error> {
reader.$r_fn()
}
}
};
}
impl_int!(u8, write_u8, read_u8);
impl_int!(u16, write_u16, read_u16);
impl_int!(u32, write_u32, read_u32);
impl_int!(i32, write_i32, read_i32);
impl_int!(u64, write_u64, read_u64);
impl_int!(i64, write_i64, read_i64);
impl<T> Readable for Vec<T>
where
T: Readable,
{
fn read<R: Reader>(reader: &mut R) -> Result<Vec<T>, Error> {
let mut buf = Vec::new();
loop {
let elem = T::read(reader);
match elem {
Ok(e) => buf.push(e),
Err(Error::IOErr(ref _d, ref kind)) if *kind == io::ErrorKind::UnexpectedEof => {
break;
}
Err(e) => return Err(e),
}
}
Ok(buf)
}
}
impl<T> Writeable for Vec<T>
where
T: Writeable,
{
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
for elmt in self {
elmt.write(writer)?;
}
Ok(())
}
}
impl<'a, A: Writeable> Writeable for &'a A {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
Writeable::write(*self, writer)
}
}
impl<A: Writeable, B: Writeable> Writeable for (A, B) {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
Writeable::write(&self.0, writer)?;
Writeable::write(&self.1, writer)
}
}
impl<A: Readable, B: Readable> Readable for (A, B) {
fn read<R: Reader>(reader: &mut R) -> Result<(A, B), Error> {
Ok((Readable::read(reader)?, Readable::read(reader)?))
}
}
impl<A: Writeable, B: Writeable, C: Writeable> Writeable for (A, B, C) {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
Writeable::write(&self.0, writer)?;
Writeable::write(&self.1, writer)?;
Writeable::write(&self.2, writer)
}
}
impl<A: Writeable, B: Writeable, C: Writeable, D: Writeable> Writeable for (A, B, C, D) {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
Writeable::write(&self.0, writer)?;
Writeable::write(&self.1, writer)?;
Writeable::write(&self.2, writer)?;
Writeable::write(&self.3, writer)
}
}
impl<A: Readable, B: Readable, C: Readable> Readable for (A, B, C) {
fn read<R: Reader>(reader: &mut R) -> Result<(A, B, C), Error> {
Ok((
Readable::read(reader)?,
Readable::read(reader)?,
Readable::read(reader)?,
))
}
}
impl<A: Readable, B: Readable, C: Readable, D: Readable> Readable for (A, B, C, D) {
fn read<R: Reader>(reader: &mut R) -> Result<(A, B, C, D), Error> {
Ok((
Readable::read(reader)?,
Readable::read(reader)?,
Readable::read(reader)?,
Readable::read(reader)?,
))
}
}
pub trait PMMRable: Writeable + Clone + Debug + DefaultHashable {
type E: Readable + Writeable + Debug;
fn as_elmt(&self) -> Self::E;
fn elmt_size() -> Option<u16>;
}
pub trait PMMRIndexHashable {
fn hash_with_index(&self, index: u64) -> Hash;
}
impl<T: DefaultHashable> PMMRIndexHashable for T {
fn hash_with_index(&self, index: u64) -> Hash {
(index, self).hash()
}
}
fn serialize_error_kind<S>(
kind: &io::ErrorKind,
serializer: S,
) -> serde::export::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match *kind {
io::ErrorKind::NotFound => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 0u32, "NotFound")
}
io::ErrorKind::PermissionDenied => serde::Serializer::serialize_unit_variant(
serializer,
"ErrorKind",
1u32,
"PermissionDenied",
),
io::ErrorKind::ConnectionRefused => serde::Serializer::serialize_unit_variant(
serializer,
"ErrorKind",
2u32,
"ConnectionRefused",
),
io::ErrorKind::ConnectionReset => serde::Serializer::serialize_unit_variant(
serializer,
"ErrorKind",
3u32,
"ConnectionReset",
),
io::ErrorKind::ConnectionAborted => serde::Serializer::serialize_unit_variant(
serializer,
"ErrorKind",
4u32,
"ConnectionAborted",
),
io::ErrorKind::NotConnected => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 5u32, "NotConnected")
}
io::ErrorKind::AddrInUse => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 6u32, "AddrInUse")
}
io::ErrorKind::AddrNotAvailable => serde::Serializer::serialize_unit_variant(
serializer,
"ErrorKind",
7u32,
"AddrNotAvailable",
),
io::ErrorKind::BrokenPipe => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 8u32, "BrokenPipe")
}
io::ErrorKind::AlreadyExists => serde::Serializer::serialize_unit_variant(
serializer,
"ErrorKind",
9u32,
"AlreadyExists",
),
io::ErrorKind::WouldBlock => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 10u32, "WouldBlock")
}
io::ErrorKind::InvalidInput => serde::Serializer::serialize_unit_variant(
serializer,
"ErrorKind",
11u32,
"InvalidInput",
),
io::ErrorKind::InvalidData => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 12u32, "InvalidData")
}
io::ErrorKind::TimedOut => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 13u32, "TimedOut")
}
io::ErrorKind::WriteZero => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 14u32, "WriteZero")
}
io::ErrorKind::Interrupted => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 15u32, "Interrupted")
}
io::ErrorKind::Other => {
serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 16u32, "Other")
}
io::ErrorKind::UnexpectedEof => serde::Serializer::serialize_unit_variant(
serializer,
"ErrorKind",
17u32,
"UnexpectedEof",
),
_ => serde::Serializer::serialize_unit_variant(serializer, "ErrorKind", 16u32, "Other"),
}
}
fn deserialize_error_kind<'de, D>(deserializer: D) -> serde::export::Result<io::ErrorKind, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum Field {
field0,
field1,
field2,
field3,
field4,
field5,
field6,
field7,
field8,
field9,
field10,
field11,
field12,
field13,
field14,
field15,
field16,
field17,
}
struct FieldVisitor;
impl<'de> serde::de::Visitor<'de> for FieldVisitor {
type Value = Field;
fn expecting(
&self,
formatter: &mut serde::export::Formatter,
) -> serde::export::fmt::Result {
serde::export::Formatter::write_str(formatter, "variant identifier")
}
fn visit_u64<E>(self, value: u64) -> serde::export::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
0u64 => serde::export::Ok(Field::field0),
1u64 => serde::export::Ok(Field::field1),
2u64 => serde::export::Ok(Field::field2),
3u64 => serde::export::Ok(Field::field3),
4u64 => serde::export::Ok(Field::field4),
5u64 => serde::export::Ok(Field::field5),
6u64 => serde::export::Ok(Field::field6),
7u64 => serde::export::Ok(Field::field7),
8u64 => serde::export::Ok(Field::field8),
9u64 => serde::export::Ok(Field::field9),
10u64 => serde::export::Ok(Field::field10),
11u64 => serde::export::Ok(Field::field11),
12u64 => serde::export::Ok(Field::field12),
13u64 => serde::export::Ok(Field::field13),
14u64 => serde::export::Ok(Field::field14),
15u64 => serde::export::Ok(Field::field15),
16u64 => serde::export::Ok(Field::field16),
17u64 => serde::export::Ok(Field::field17),
_ => serde::export::Err(serde::de::Error::invalid_value(
serde::de::Unexpected::Unsigned(value),
&"variant index 0 <= i < 18",
)),
}
}
fn visit_str<E>(self, value: &str) -> serde::export::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"NotFound" => serde::export::Ok(Field::field0),
"PermissionDenied" => serde::export::Ok(Field::field1),
"ConnectionRefused" => serde::export::Ok(Field::field2),
"ConnectionReset" => serde::export::Ok(Field::field3),
"ConnectionAborted" => serde::export::Ok(Field::field4),
"NotConnected" => serde::export::Ok(Field::field5),
"AddrInUse" => serde::export::Ok(Field::field6),
"AddrNotAvailable" => serde::export::Ok(Field::field7),
"BrokenPipe" => serde::export::Ok(Field::field8),
"AlreadyExists" => serde::export::Ok(Field::field9),
"WouldBlock" => serde::export::Ok(Field::field10),
"InvalidInput" => serde::export::Ok(Field::field11),
"InvalidData" => serde::export::Ok(Field::field12),
"TimedOut" => serde::export::Ok(Field::field13),
"WriteZero" => serde::export::Ok(Field::field14),
"Interrupted" => serde::export::Ok(Field::field15),
"Other" => serde::export::Ok(Field::field16),
"UnexpectedEof" => serde::export::Ok(Field::field17),
_ => serde::export::Err(serde::de::Error::unknown_variant(value, VARIANTS)),
}
}
fn visit_bytes<E>(self, value: &[u8]) -> serde::export::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
b"NotFound" => serde::export::Ok(Field::field0),
b"PermissionDenied" => serde::export::Ok(Field::field1),
b"ConnectionRefused" => serde::export::Ok(Field::field2),
b"ConnectionReset" => serde::export::Ok(Field::field3),
b"ConnectionAborted" => serde::export::Ok(Field::field4),
b"NotConnected" => serde::export::Ok(Field::field5),
b"AddrInUse" => serde::export::Ok(Field::field6),
b"AddrNotAvailable" => serde::export::Ok(Field::field7),
b"BrokenPipe" => serde::export::Ok(Field::field8),
b"AlreadyExists" => serde::export::Ok(Field::field9),
b"WouldBlock" => serde::export::Ok(Field::field10),
b"InvalidInput" => serde::export::Ok(Field::field11),
b"InvalidData" => serde::export::Ok(Field::field12),
b"TimedOut" => serde::export::Ok(Field::field13),
b"WriteZero" => serde::export::Ok(Field::field14),
b"Interrupted" => serde::export::Ok(Field::field15),
b"Other" => serde::export::Ok(Field::field16),
b"UnexpectedEof" => serde::export::Ok(Field::field17),
_ => {
let value = &serde::export::from_utf8_lossy(value);
serde::export::Err(serde::de::Error::unknown_variant(value, VARIANTS))
}
}
}
}
impl<'de> serde::Deserialize<'de> for Field {
#[inline]
fn deserialize<D>(deserializer: D) -> serde::export::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
serde::Deserializer::deserialize_identifier(deserializer, FieldVisitor)
}
}
struct Visitor<'de> {
marker: serde::export::PhantomData<io::ErrorKind>,
lifetime: serde::export::PhantomData<&'de ()>,
}
impl<'de> serde::de::Visitor<'de> for Visitor<'de> {
type Value = io::ErrorKind;
fn expecting(
&self,
formatter: &mut serde::export::Formatter,
) -> serde::export::fmt::Result {
serde::export::Formatter::write_str(formatter, "enum io::ErrorKind")
}
fn visit_enum<A>(self, data: A) -> serde::export::Result<Self::Value, A::Error>
where
A: serde::de::EnumAccess<'de>,
{
match match serde::de::EnumAccess::variant(data) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
} {
(Field::field0, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::NotFound)
}
(Field::field1, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::PermissionDenied)
}
(Field::field2, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::ConnectionRefused)
}
(Field::field3, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::ConnectionReset)
}
(Field::field4, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::ConnectionAborted)
}
(Field::field5, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::NotConnected)
}
(Field::field6, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::AddrInUse)
}
(Field::field7, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::AddrNotAvailable)
}
(Field::field8, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::BrokenPipe)
}
(Field::field9, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::AlreadyExists)
}
(Field::field10, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::WouldBlock)
}
(Field::field11, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::InvalidInput)
}
(Field::field12, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::InvalidData)
}
(Field::field13, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::TimedOut)
}
(Field::field14, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::WriteZero)
}
(Field::field15, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::Interrupted)
}
(Field::field16, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::Other)
}
(Field::field17, variant) => {
match serde::de::VariantAccess::unit_variant(variant) {
serde::export::Ok(val) => val,
serde::export::Err(err) => {
return serde::export::Err(err);
}
};
serde::export::Ok(io::ErrorKind::UnexpectedEof)
}
}
}
}
const VARIANTS: &[&str] = &[
"NotFound",
"PermissionDenied",
"ConnectionRefused",
"ConnectionReset",
"ConnectionAborted",
"NotConnected",
"AddrInUse",
"AddrNotAvailable",
"BrokenPipe",
"AlreadyExists",
"WouldBlock",
"InvalidInput",
"InvalidData",
"TimedOut",
"WriteZero",
"Interrupted",
"Other",
"UnexpectedEof",
];
serde::Deserializer::deserialize_enum(
deserializer,
"ErrorKind",
VARIANTS,
Visitor {
marker: serde::export::PhantomData::<io::ErrorKind>,
lifetime: serde::export::PhantomData,
},
)
}