use byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
use thiserror::Error;
use serde::{Deserialize, Serialize};
use std::fmt;
use std::io::{self, Read, Write};
use std::marker;
pub const PROTOCOL_VERSION: u32 = 1;
#[derive(Clone, Eq, PartialEq, Debug, Serialize, Deserialize, Error)]
pub enum Error {
#[error("IOerr: {:?} --- {:?}", .0, .1)]
IOErr(
String,
#[serde(
serialize_with = "serialize_error_kind",
deserialize_with = "deserialize_error_kind"
)]
io::ErrorKind,
),
#[error("expected {expected:?}, got {received:?}")]
UnexpectedData {
expected: Vec<u8>,
received: Vec<u8>,
},
#[error("corrupted data")]
CorruptedData,
#[error("count error")]
CountError,
#[error("too large read")]
TooLargeReadErr,
#[error("hex error `{0}`")]
HexError(String),
#[error("sort order")]
SortError,
#[error("duplicate")]
DuplicateError,
#[error("invalid block version")]
InvalidBlockVersion,
#[error("invalid variable integer encoding")]
InvalidVarInt,
}
impl From<io::Error> for Error {
fn from(e: io::Error) -> Error {
Error::IOErr(format!("{}", e), e.kind())
}
}
#[derive(Copy, Clone, PartialEq, Eq)]
pub enum SerializationMode {
Full,
Hash,
}
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];
LittleEndian::write_u16(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_u32(&mut self, n: u32) -> Result<(), Error> {
let mut bytes = [0; 4];
LittleEndian::write_u32(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_i32(&mut self, n: i32) -> Result<(), Error> {
let mut bytes = [0; 4];
LittleEndian::write_i32(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_u64(&mut self, n: u64) -> Result<(), Error> {
let mut bytes = [0; 8];
LittleEndian::write_u64(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_i64(&mut self, n: i64) -> Result<(), Error> {
let mut bytes = [0; 8];
LittleEndian::write_i64(&mut bytes, n);
self.write_fixed_bytes(&bytes)
}
fn write_bytes<T: AsFixedBytes>(&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: AsFixedBytes>(&mut self, fixed: &T) -> Result<(), Error>;
}
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;
}
pub trait Writeable {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error>;
}
pub struct IteratingReader<'a, T> {
count: u64,
curr: u64,
reader: &'a mut dyn Reader,
_marker: marker::PhantomData<T>,
}
impl<'a, T> IteratingReader<'a, T> {
pub fn new(reader: &'a mut dyn Reader, count: u64) -> IteratingReader<'a, T> {
let curr = 0;
IteratingReader {
count,
curr,
reader,
_marker: marker::PhantomData,
}
}
}
impl<'a, T> Iterator for IteratingReader<'a, T>
where
T: Readable,
{
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>(reader: &mut dyn Reader, count: u64) -> Result<Vec<T>, Error>
where
T: Readable,
{
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 fn local() -> ProtocolVersion {
ProtocolVersion(PROTOCOL_VERSION)
}
}
impl fmt::Display for ProtocolVersion {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl ProtocolVersion {
pub fn local_db() -> ProtocolVersion {
ProtocolVersion(1)
}
}
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(reader: &mut dyn Reader) -> Result<ProtocolVersion, Error> {
let version = reader.read_u32()?;
Ok(ProtocolVersion(version))
}
}
pub trait Readable
where
Self: Sized,
{
fn read(reader: &mut dyn Reader) -> Result<Self, Error>;
}
pub fn deserialize<T: Readable>(
source: &mut dyn Read,
version: ProtocolVersion,
) -> Result<T, Error> {
let mut reader = BinReader::new(source, version);
T::read(&mut reader)
}
pub fn deserialize_default<T: Readable>(source: &mut dyn Read) -> 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> {
source: &'a mut dyn Read,
version: ProtocolVersion,
}
impl<'a> BinReader<'a> {
pub fn new(source: &'a mut dyn Read, version: ProtocolVersion) -> BinReader<'a> {
BinReader { source, version }
}
}
fn map_io_err(err: io::Error) -> Error {
Error::IOErr(format!("{}", err), err.kind())
}
impl<'a> Reader for BinReader<'a> {
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::<LittleEndian>().map_err(map_io_err)
}
fn read_u32(&mut self) -> Result<u32, Error> {
self.source.read_u32::<LittleEndian>().map_err(map_io_err)
}
fn read_i32(&mut self) -> Result<i32, Error> {
self.source.read_i32::<LittleEndian>().map_err(map_io_err)
}
fn read_u64(&mut self) -> Result<u64, Error> {
self.source.read_u64::<LittleEndian>().map_err(map_io_err)
}
fn read_i64(&mut self) -> Result<i64, Error> {
self.source.read_i64::<LittleEndian>().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(LittleEndian::read_u16(&buf[..]))
}
fn read_u32(&mut self) -> Result<u32, Error> {
let buf = self.read_fixed_bytes(4)?;
Ok(LittleEndian::read_u32(&buf[..]))
}
fn read_i32(&mut self) -> Result<i32, Error> {
let buf = self.read_fixed_bytes(4)?;
Ok(LittleEndian::read_i32(&buf[..]))
}
fn read_u64(&mut self) -> Result<u64, Error> {
let buf = self.read_fixed_bytes(8)?;
Ok(LittleEndian::read_u64(&buf[..]))
}
fn read_i64(&mut self) -> Result<i64, Error> {
let buf = self.read_fixed_bytes(8)?;
Ok(LittleEndian::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
}
}
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: AsFixedBytes>(&mut self, fixed: &T) -> Result<(), Error> {
let bs = fixed.as_ref();
self.sink.write_all(bs)?;
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(reader: &mut dyn Reader) -> 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(reader: &mut dyn Reader) -> 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(reader: &mut dyn Reader) -> 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(reader: &mut dyn Reader) -> 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(reader: &mut dyn Reader) -> Result<(A, B, C, D), Error> {
Ok((
Readable::read(reader)?,
Readable::read(reader)?,
Readable::read(reader)?,
Readable::read(reader)?,
))
}
}
impl Writeable for [u8; 4] {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_bytes(self)
}
}
impl Readable for crate::dalek::scalar::Scalar {
fn read(reader: &mut dyn Reader) -> Result<crate::dalek::scalar::Scalar, Error> {
let v = reader.read_fixed_bytes(32)?;
let mut a = [0; 32];
a.copy_from_slice(&v[..]);
Ok(crate::dalek::scalar::Scalar::from_bits(a))
}
}
impl Writeable for crate::dalek::scalar::Scalar {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_fixed_bytes(self.as_bytes())
}
}
impl Readable for crate::dalek::ristretto::CompressedRistretto {
fn read(
reader: &mut dyn Reader,
) -> Result<crate::dalek::ristretto::CompressedRistretto, Error> {
let v = reader.read_fixed_bytes(32)?;
Ok(crate::dalek::ristretto::CompressedRistretto::from_slice(
&v[..],
))
}
}
impl Writeable for crate::dalek::ristretto::CompressedRistretto {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
writer.write_fixed_bytes(self.as_bytes())
}
}
pub trait FixedLength {
const LEN: usize;
}
pub trait AsFixedBytes: Sized + AsRef<[u8]> {
fn len(&self) -> usize;
}
impl<'a> AsFixedBytes for &'a [u8] {
fn len(&self) -> usize {
1
}
}
impl AsFixedBytes for Vec<u8> {
fn len(&self) -> usize {
self.len()
}
}
impl AsFixedBytes for [u8; 1] {
fn len(&self) -> usize {
1
}
}
impl AsFixedBytes for [u8; 2] {
fn len(&self) -> usize {
2
}
}
impl AsFixedBytes for [u8; 4] {
fn len(&self) -> usize {
4
}
}
impl AsFixedBytes for [u8; 6] {
fn len(&self) -> usize {
6
}
}
impl AsFixedBytes for [u8; 8] {
fn len(&self) -> usize {
8
}
}
impl AsFixedBytes for [u8; 16] {
fn len(&self) -> usize {
16
}
}
impl AsFixedBytes for [u8; 20] {
fn len(&self) -> usize {
20
}
}
impl AsFixedBytes for [u8; 32] {
fn len(&self) -> usize {
32
}
}
impl AsFixedBytes for String {
fn len(&self) -> usize {
self.len()
}
}
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: &'static [&'static 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,
},
)
}