tar 0.4.5

A Rust implementation of a TAR file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire contents are never required to be entirely resident in memory all at once.
Documentation 
use std::io;
use std::str;
use std::slice;

use other;

/// An iterator over the pax extensions in an archive entry.
///
/// This iterator yields structures which can themselves be parsed into
/// key/value pairs.
pub struct PaxExtensions<'entry> {
    data: slice::Split<'entry, u8, fn(&u8) -> bool>,
}

/// A key/value pair corresponding to a pax extension.
pub struct PaxExtension<'entry> {
    key: &'entry [u8],
    value: &'entry [u8],
}

pub fn pax_extensions(a: &[u8]) -> PaxExtensions {
    fn is_newline(a: &u8) -> bool { *a == b'\n' }
    PaxExtensions { data: a.split(is_newline) }
}

impl<'entry> Iterator for PaxExtensions<'entry> {
    type Item = io::Result<PaxExtension<'entry>>;

    fn next(&mut self) -> Option<io::Result<PaxExtension<'entry>>> {
        let line = match self.data.next() {
            Some(line) if line.is_empty() => return None,
            Some(line) => line,
            None => return None,
        };

        Some(line.iter().position(|b| *b == b' ').and_then(|i| {
            str::from_utf8(&line[..i]).ok().and_then(|len| {
                len.parse::<usize>().ok().map(|j| (i + 1, j))
            })
        }).and_then(|(kvstart, reported_len)| {
            if line.len() + 1 == reported_len {
                line[kvstart..].iter().position(|b| *b == b'=').map(|equals| {
                    (kvstart, equals)
                })
            } else {
                None
            }
        }).map(|(kvstart, equals)| {
            PaxExtension {
                key: &line[kvstart..kvstart + equals],
                value: &line[kvstart + equals + 1..],
            }
        }).ok_or_else(|| {
            other("malformed pax extension")
        }))
    }
}

impl<'entry> PaxExtension<'entry> {
    /// Returns the key for this key/value pair parsed as a string.
    ///
    /// May fail if the key isn't actually utf-8.
    pub fn key(&self) -> Result<&str, str::Utf8Error> {
        str::from_utf8(self.key)
    }

    /// Returns the underlying raw bytes for the key of this key/value pair.
    pub fn key_bytes(&self) -> &[u8] {
        self.key
    }

    /// Returns the value for this key/value pair parsed as a string.
    ///
    /// May fail if the value isn't actually utf-8.
    pub fn value(&self) -> Result<&str, str::Utf8Error> {
        str::from_utf8(self.value)
    }

    /// Returns the underlying raw bytes for this value of this key/value pair.
    pub fn value_bytes(&self) -> &[u8] {
        self.value
    }
}