path: root/openpgp/src/serialize/writer/mod.rs

//! Stackable writers.

#[cfg(feature = "compression-bzip2")]
mod writer_bzip2;
#[cfg(feature = "compression-bzip2")]
pub use self::writer_bzip2::BZ;
#[cfg(feature = "compression-deflate")]
mod writer_deflate;
#[cfg(feature = "compression-deflate")]
pub use self::writer_deflate::{ZIP, ZLIB};

use std::fmt;
use std::io;

use symmetric;
use {
    Result,
    SymmetricAlgorithm,
};

/// A stack of writers.
///
/// We use trait objects as the unit of composition.  This is a
/// compiler limitation, we may use impl trait in the future.
pub type Stack<'a, C> = Box<'a + Stackable<'a, C>>;

/// Makes a writer stackable and provides convenience functions.
pub trait Stackable<'a, C> : io::Write + fmt::Debug {
    /// Recovers the inner stackable.
    ///
    /// This can fail if the current `Stackable` has buffered data
    /// that hasn't been written to the underlying `Stackable`.
    fn into_inner(self: Box<Self>) -> Result<Option<Stack<'a, C>>>;

    /// Pops the stackable from the stack, detaching it.
    ///
    /// Returns the detached stack.
    fn pop(&mut self) -> Result<Option<Stack<'a, C>>>;

    /// Sets the inner stackable.
    fn mount(&mut self, new: Stack<'a, C>);

    /// Returns a mutable reference to the inner `Writer`, if
    /// any.
    ///
    /// It is a very bad idea to write any data from the inner
    /// `Writer`, but it can sometimes be useful to get the cookie.
    fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>>;

    /// Returns a reference to the inner `Writer`.
    fn inner_ref(&self) -> Option<&Stackable<'a, C>>;

    /// Sets the cookie and returns the old value.
    fn cookie_set(&mut self, cookie: C) -> C;

    /// Returns a reference to the cookie.
    fn cookie_ref(&self) -> &C;

    /// Returns a mutable reference to the cookie.
    fn cookie_mut(&mut self) -> &mut C;

    /// Writes a byte.
    fn write_u8(&mut self, b: u8) -> io::Result<()> {
        let b : [u8; 1] = [b; 1];
        self.write_all(&b[..])
    }

    /// Writes a big endian `u16`.
    fn write_be_u16(&mut self, n: u16) -> io::Result<()> {
        let b : [u8; 2] = [ ((n >> 8) & 0xFF) as u8, (n & 0xFF) as u8 ];
        self.write_all(&b[..])
    }

    /// Writes a big endian `u32`.
    fn write_be_u32(&mut self, n: u32) -> io::Result<()> {
        let b : [u8; 4] = [ (n >> 24) as u8, ((n >> 16) & 0xFF) as u8,
                             ((n >> 8) & 0xFF) as u8, (n & 0xFF) as u8 ];
        self.write_all(&b[..])
    }
}

/// Make a `Box<Stackable>` look like a Stackable.
impl <'a, C> Stackable<'a, C> for Stack<'a, C> {
    fn into_inner(self: Box<Self>) -> Result<Option<Stack<'a, C>>> {
        (*self).into_inner()
    }
    /// Recovers the inner stackable.
    fn pop(&mut self) -> Result<Option<Stack<'a, C>>> {
        self.as_mut().pop()
    }
    /// Sets the inner stackable.
    fn mount(&mut self, new: Stack<'a, C>) {
        self.as_mut().mount(new);
    }
    fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> {
        self.as_mut().inner_mut()
    }
    fn inner_ref(&self) -> Option<&Stackable<'a, C>> {
        self.as_ref().inner_ref()
    }
    fn cookie_set(&mut self, cookie: C) -> C {
        self.as_mut().cookie_set(cookie)
    }
    fn cookie_ref(&self) -> &C {
        self.as_ref().cookie_ref()
    }
    fn cookie_mut(&mut self) -> &mut C {
        self.as_mut().cookie_mut()
    }
}

/// Maps a function over the stack of writers.
#[allow(dead_code)]
pub fn map<C, F>(head: &Stackable<C>, mut fun: F)
    where F: FnMut(&Stackable<C>) -> bool {
    let mut ow = Some(head);
    while let Some(w) = ow {
        if ! fun(w) {
            break;
        }
        ow = w.inner_ref()
    }
}

/// Maps a function over the stack of mutable writers.
#[allow(dead_code)]
pub fn map_mut<C, F>(head: &mut Stackable<C>, mut fun: F)
    where F: FnMut(&mut Stackable<C>) -> bool {
    let mut ow = Some(head);
    while let Some(w) = ow {
        if ! fun(w) {
            break;
        }
        ow = w.inner_mut()
    }
}

/// Dumps the writer stack.
#[allow(dead_code)]
pub fn dump<C>(head: &Stackable<C>) {
    let mut depth = 0;
    map(head, |w| {
        eprintln!("{}: {:?}", depth, w);
        depth += 1;
        true
    });
}

pub struct Identity<'a, C> {
    inner: Option<Stack<'a, C>>,
    co