wiring 0.1.6

use std::io::{Read, Write};

use serde::ser::{
    SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple, SerializeTupleStruct,
    SerializeTupleVariant,
};

pub struct SyncSerializer {
    buf: std::io::Cursor<Vec<u8>>,
    // needs reference to wire
}

impl<'a> serde::Serializer for &'a mut SyncSerializer {
    type Ok = ();
    type Error = core::fmt::Error;
    type SerializeSeq = Self;
    type SerializeMap = Self;
    type SerializeStruct = Self;
    type SerializeStructVariant = Self;
    type SerializeTuple = Self;
    type SerializeTupleStruct = Self;
    type SerializeTupleVariant = Self;
    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        let v = &[v as u8];
        self.buf.write_all(v).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        let v = &[v as u8];
        self.buf.write_all(v).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        let v = &[v];
        self.buf.write_all(v).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        let len = v.len() as u64;
        self.serialize_u64(len).map_err(|e| core::fmt::Error)?;
        self.buf.write_all(v).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        let len = v.as_bytes().len() as u64;
        self.serialize_u64(len).map_err(|e| core::fmt::Error)?;
        self.buf.write_all(v.as_bytes()).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        let b = v.to_be_bytes();
        self.buf.write_all(&b).map_err(|e| core::fmt::Error)?;
        Ok(())
    }
    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        self.serialize_unit()
    }
    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
        let v = v as u32;
        self.serialize_u32(v)
    }
    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: serde::Serialize,
    {
        self.serialize_u8(1)?;
        value.serialize(self)
    }
    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        let len = len.unwrap_or_default() as u64;
        self.serialize_u64(len)?;
        Ok(self)
    }
    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        let len = len.unwrap_or_default() as u64;
        self.serialize_u64(len)?;
        Ok(self)
    }
    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        Ok(self)
    }
    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
        Ok(self)
    }
    fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: serde::Serialize,
    {
        value.serialize(self)
    }
    fn serialize_struct_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        Ok(self)
    }
    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        // units in wire are signals
        self.serialize_u8(0)?;
        Ok(())
    }
    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
        if len == 0 {
            self.serialize_unit()?;
        }
        Ok(self)
    }
    fn serialize_newtype_variant<T: ?Sized>(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: serde::Serialize,
    {
        self.serialize_u32(variant_index)?;
        value.serialize(self)
    }
    fn serialize_tuple_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Ok(self)
    }
    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
        self.serialize_unit()
    }
    fn serialize_unit_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.serialize_u32(variant_index)
    }

    fn is_human_readable(&self) -> bool {
        false
    }
}

impl<'a> SerializeMap for &'a mut SyncSerializer {
    type Ok = ();
    type Error = core::fmt::Error;
    fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
    where
        K: serde::Serialize,
        V: serde::Serialize,
    {
        self.serialize_key(key)?;
        self.serialize_value(value)
    }
    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        key.serialize(&mut **self)
    }
    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut **self)
    }
    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> SerializeSeq for &'a mut SyncSerializer {
    type Ok = ();
    type Error = core::fmt::Error;
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut **self)
    }
    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> SerializeStruct for &'a mut SyncSerializer {
    type Ok = ();
    type Error = core::fmt::Error;
    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut **self)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> SerializeStructVariant for &'a mut SyncSerializer {
    type Ok = ();
    type Error = core::fmt::Error;
    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut **self)
    }
    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> SerializeTupleStruct for &'a mut SyncSerializer {
    type Ok = ();
    type Error = core::fmt::Error;
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut **self)
    }
    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> SerializeTuple for &'a mut SyncSerializer {
    type Ok = ();
    type Error = core::fmt::Error;
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut **self)
    }
    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> SerializeTupleVariant for &'a mut SyncSerializer {
    type Ok = ();
    type Error = core::fmt::Error;
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        value.serialize(&mut **self)
    }
    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

use serde::de::{DeserializeSeed, Deserializer, EnumAccess, MapAccess, SeqAccess, VariantAccess};

pub struct SyncDeserializer {
    buf: std::io::Cursor<Vec<u8>>,
    // needs reference to wire
}

impl SyncDeserializer {
    fn deserialize_len(&mut self) -> Result<usize, SyncError> {
        let mut b = [0u8; 8];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = u64::from_be_bytes(b);
        let len: usize = v.try_into().map_err(|e| {
            SyncError(std::io::Error::new(
                std::io::ErrorKind::OutOfMemory,
                "deserialize_bytes len overflow usize",
            ))
        })?;
        Ok(len)
    }
}

impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut SyncDeserializer {
    type Error = SyncError;
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
    }
    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 1];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        visitor.visit_i8(b[0] as i8)
    }
    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 1];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = u8::from_be_bytes(b);
        visitor.visit_u8(v)
    }
    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 1];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        visitor.visit_bool(b[0] != 0)
    }
    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 4];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = f32::from_be_bytes(b);
        visitor.visit_f32(v)
    }
    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 4];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = i32::from_be_bytes(b);
        visitor.visit_i32(v)
    }
    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 8];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = i64::from_be_bytes(b);
        visitor.visit_i64(v)
    }
    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 8];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = u64::from_be_bytes(b);
        visitor.visit_u64(v)
    }
    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 8];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = f64::from_be_bytes(b);
        visitor.visit_f64(v)
    }
    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 2];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = u16::from_be_bytes(b);
        visitor.visit_u16(v)
    }
    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 2];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = i16::from_be_bytes(b);
        visitor.visit_i16(v)
    }
    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 4];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = u32::from_be_bytes(b);
        visitor.visit_u32(v)
    }
    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 16];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = u128::from_be_bytes(b);
        visitor.visit_u128(v)
    }
    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 16];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = i128::from_be_bytes(b);
        visitor.visit_i128(v)
    }
    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let len = self.deserialize_len()?;
        let mut b = vec![0u8; len];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        visitor.visit_bytes(&b)
    }
    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let len = self.deserialize_len()?;
        let mut b = vec![0u8; len];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        visitor.visit_byte_buf(b)
    }
    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 1];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        if b[0] != 0 {
            return Err(SyncError(std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                "deserialize_unit expected 0u8",
            )));
        } else {
            visitor.visit_unit()
        }
    }
    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let len = self.deserialize_len()?;
        let mut b = vec![0u8; len];
        let v = String::from_utf8(b)
            .map_err(|e| SyncError(std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string())))?;
        visitor.visit_string(v)
    }
    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let len = self.deserialize_len()?;
        let mut b = vec![0u8; len];
        let v = String::from_utf8(b)
            .map_err(|e| SyncError(std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string())))?;
        visitor.visit_str(&v)
    }
    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let mut b = [0u8; 1];
        self.buf.read_exact(&mut b).map_err(|e| SyncError(e))?;
        let v = match b[0] {
            0 => visitor.visit_none(),
            _ => visitor.visit_some(self),
        };
        v
    }
    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_unit(visitor)
    }
    fn deserialize_struct<V>(
        self,
        name: &'static str,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_tuple(0, visitor)
    }
    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let seq = SeqTupleInner::new(self);
        visitor.visit_seq(seq)
    }
    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let len = self.deserialize_len()?;
        let seq = SeqVecInner::new(self, len);
        visitor.visit_seq(seq)
    }
    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        let len = self.deserialize_len()?;
        let map = SeqMapInner::new(self, len);
        visitor.visit_map(map)
    }
    fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_tuple(len, visitor)
    }
    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_newtype_struct(self)
    }
    fn deserialize_enum<V>(
        self,
        name: &'static str,
        variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        // we deserlize the unit
        // visitor.visit_enum(data);
    }
}

struct EnumInner<'a> {
    de: &'a mut SyncDeserializer,
}

impl<'a> EnumInner<'a> {
    fn new(de: &'a mut SyncDeserializer) -> Self {
        Self { de }
    }
}

impl<'a> EnumAccess<'a> for EnumInner<'a> {
    type Error = SyncError;
    type Variant = Self;

    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
    where
        V: DeserializeSeed<'a>,
    {
        // The `deserialize_enum` method parsed a `{` character so we are
        // currently inside of a map. The seed will be deserializing itself from
        // the key of the map.
        //

        let val = seed.deserialize(&mut *self.de)?;
        // the value is index, which then must tell us how to to decode next value.

        // Parse the colon separating map key from value.
        if self.de.next_char()? == ':' {
            Ok((val, self))
        } else {
            Err(Error::ExpectedMapColon)
        }
    }
}

impl<'a> VariantAccess<'a> for EnumInner<'a> {
    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'a>,
    {
        // in thery
    }
}
struct SeqVecInner<'a> {
    de: &'a mut SyncDeserializer,
    len: usize,
}

impl<'a> SeqVecInner<'a> {
    fn new(de: &'a mut SyncDeserializer, len: usize) -> Self {
        SeqVecInner { de, len }
    }
}

impl<'a> SeqAccess<'a> for SeqVecInner<'a> {
    type Error = SyncError;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, SyncError>
    where
        T: DeserializeSeed<'a>,
    {
        if self.len == 0 {
            return Ok(None);
        }
        self.len -= 1;

        seed.deserialize(&mut *self.de).map(Some)
    }
}

struct SeqMapInner<'a> {
    de: &'a mut SyncDeserializer,
    len: usize,
}

impl<'a> SeqMapInner<'a> {
    fn new(de: &'a mut SyncDeserializer, len: usize) -> Self {
        Self { de, len }
    }
}

impl<'a> MapAccess<'de> for SeqMapInner<'a> {
    type Error = SyncError;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
    where
        K: DeserializeSeed<'a>,
    {
        // Check if there are no more entries.
        if self.len == 0 {
            return Ok(None);
        }
        self.len -= 0;
        // Deserialize a map key.
        seed.deserialize(&mut *self.de).map(Some)
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
    where
        V: DeserializeSeed<'a>,
    {
        // Deserialize a map value.
        seed.deserialize(&mut *self.de)
    }
}

struct SeqTupleInner<'a> {
    de: &'a mut SyncDeserializer,
}

impl<'a> SeqTupleInner<'a> {
    fn new(de: &'a mut SyncDeserializer) -> Self {
        SeqTupleInner { de }
    }
}

impl<'a> SeqAccess<'a> for SeqTupleInner<'a> {
    type Error = SyncError;

    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
    where
        T: serde::Deserialize<'a>,
    {
        T::deserialize(&mut *self.de).map(Some)
    }
    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
    where
        T: DeserializeSeed<'a>,
    {
        seed.deserialize(&mut *self.de).map(Some)
    }
}

#[derive(Debug)]
struct SyncError(std::io::Error);

impl std::fmt::Display for SyncError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

impl serde::de::Error for SyncError {
    fn custom<T>(msg: T) -> Self
    where
        T: std::fmt::Display,
    {
        SyncError(std::io::Error::new(std::io::ErrorKind::Other, msg.to_string()))
    }
}

impl std::error::Error for SyncError {}