extra-embedded-io-adapters 0.1.0

//! Types that encapsulate foreign types into embedded-io writers.
//!
//! Exceeding what the [embedded-io-adapters](https://crates.io/crates/embedded-io-adapters) (which
//! gets co-developed with [`embedded-io`]) does,
//!
//! * it goes both ways: It implements [`embedded_io::Write`] for foreign types ([`WritableCrc`]
//!   etc.), but also foreign traits for any implementation of [`embedded_io::Write`]
//!   ([`ForeignWritable`]).
//! * it is not too picky in what it implements:
//!   * it interfaces with crates that are not stable (e.g. [`digest::Digest`])
//!   * it interfaces with crates that are more bespoke but which would still not implement
//!     `embedded-io` traits (e.g. [`ciborium_io::Write`])
//!
//! This library is not intended to be part of any other crate's public dependencies, and will do
//! breaking releases whenever its own public dependencies change. Users who want to support
//! different versions of other crates may need to resort to using multiple versions of this crate.
#![no_std]

#[cfg(test)]
mod tests;

use embedded_io::{ErrorType, Write};

/// Wrapper around any [`embedded_io::Write`] that implements additional Write-ish traits.
///
/// This implements various CBOR encoders' custom write traits (currently only [`ciborium_io::Write`]).
pub struct ForeignWritable<T: Write>(pub T);

#[cfg(feature = "ciborium_0_2")]
impl<T: Write> ciborium_io::Write for ForeignWritable<T> {
    type Error = T::Error;

    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
        Write::write_all(&mut self.0, buf)
    }

    fn flush(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}

/// Wrapper around any [`digest::Digest`] (typically hashes) that implements [`embedded_io::Write`]
/// to send data into a digest.
pub struct WritableDigest<D: digest::Digest>(pub D);

impl<D: digest::Digest> ErrorType for WritableDigest<D> {
    type Error = core::convert::Infallible;
}

impl<D: digest::Digest> Write for WritableDigest<D> {
    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
        self.0.update(buf);
        Ok(buf.len())
    }

    fn flush(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}

/// Wrapper around any [`crc::Digest`] (typically hashes) that implements [`embedded_io::Write`]
/// to send data into a digest.
pub struct WritableCrc<'c, W: crc::Width>(pub crc::Digest<'c, W>);

impl<W: crc::Width> ErrorType for WritableCrc<'_, W> {
    type Error = core::convert::Infallible;
}

impl Write for WritableCrc<'_, u64> {
    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
        self.0.update(buf);
        Ok(buf.len())
    }

    fn flush(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}

impl Write for WritableCrc<'_, u32> {
    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
        self.0.update(buf);
        Ok(buf.len())
    }

    fn flush(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}

//
// FIXME: These were convenient constructors on the WindowedInfinity; should we have them as an
// extension trait on every embedded_ioWrite?
//

/*
    /// Create a Tee (a T-shaped writer) that writes both to this WindowedInfinity and some
    /// [digest::Digest].
    ///
    /// The resulting type implements all the same writers as the WindowedInfinity, and offers an
    /// `into_windowed_and_digest(self) -> (WindowedInfinity, Digest)` to get both back after
    /// writing as completed.
    pub fn tee_digest<D: digest::Digest>(self) -> TeeForDigest<'a, D> {
        tee::Tee {
            w1: self,
            w2: wrappers::WritableDigest(D::new()),
        }
    }

    /// Create a Tee (a T-shaped writer) that writes both to this WindowedInfinity and some
    /// [crc::Digest].
    ///
    /// This is limited to u64 CRCs due to <https://github.com/mrhooray/crc-rs/issues/79>, and
    /// indirectly the availability of const traits.
    pub fn tee_crc64<'c>(self, crc: &'c crc::Crc<u64>) -> TeeForCrc<'a, 'c, u64> {
        tee::Tee {
            w1: self,
            w2: wrappers::WritableCrc(crc.digest()),
        }
    }

    /// Create a Tee (a T-shaped writer) that writes both to this WindowedInfinity and some
    /// [crc::Digest].
    ///
    /// This is limited to u32 CRCs due to <https://github.com/mrhooray/crc-rs/issues/79>, and
    /// indirectly the availability of const traits.
    pub fn tee_crc32<'c>(self, crc: &'c crc::Crc<u32>) -> TeeForCrc<'a, 'c, u32> {
        tee::Tee {
            w1: self,
            w2: wrappers::WritableCrc(crc.digest()),
        }
    }

impl<'a, 'c> crate::tee::Tee<crate::WindowedInfinity<'a>, WritableCrc<'c, u64>> {
    pub fn into_windowed_and_crc(self) -> (crate::WindowedInfinity<'a>, crc::Digest<'c, u64>) {
        (self.w1, self.w2.0)
    }
}

impl<'a, 'c> crate::tee::Tee<crate::WindowedInfinity<'a>, WritableCrc<'c, u32>> {
    pub fn into_windowed_and_crc(self) -> (crate::WindowedInfinity<'a>, crc::Digest<'c, u32>) {
        (self.w1, self.w2.0)
    }
}
*/