Struct SkipEncodingBom 

pub struct SkipEncodingBom<'a, R: Read> { /* private fields */ }

Read from I/O and skip the initial encoding BOM if present.

Implementations

impl<'a, R: Read> SkipEncodingBom<'a, R>

pub fn new(bom_types: &'a [BomType], reader: R) -> Self

Initialize an encoding BOM skip struct given any stream reader.

Arguments

• bom_types - a slice with the types of BOM to check for. To skip any of the supported BOMs, pass BomType::all.
• reader - the underlying input stream reader.

pub fn read_bom(&mut self) -> Result<Option<BomType>>

Read the BOM from a reader if it is present and return the BOM found as an Option with a BomType or None if it was not found.

If the reader ends before a BOM if confirmed, None will be returned.

pub fn bom_found(&self) -> Option<Option<BomType>>

Return the BOM previously found as an inner Option with a BomType or None if it was not found, or None for the outer option if the presence of a BOM could not be determined yet.

Examples

use skip_bom::{BomType, SkipEncodingBom};
use std::io::{Cursor, Read};
 
// No BOM was found.
{
    const BYTES: &'static [u8] = b"This stream does not have a BOM.";
    let mut reader = SkipEncodingBom::new(BomType::all(), Cursor::new(BYTES));
    let mut buf = Default::default();
    let _ = reader.read_to_end(&mut buf).unwrap();
    assert_eq!(b"This stream does not have a BOM.", buf.as_slice());
    assert_eq!(Some(None), reader.bom_found());
}
// Nothing was read yet.
{
    const BYTES: &'static [u8] = b"\xEF\xBB\xBFThis stream starts with a UTF-8 BOM.";
    let reader = SkipEncodingBom::new(BomType::all(), Cursor::new(BYTES));
    assert_eq!(None, reader.bom_found());
}
// The stream is to small.
{
    const BYTES: &'static [u8] = b"\xEF\xBB";
    let mut reader = SkipEncodingBom::new(BomType::all(), Cursor::new(BYTES));
    let mut buf = Default::default();
    let _ = reader.read_to_end(&mut buf).unwrap();
    assert_eq!(None, reader.bom_found());
    assert_eq!(b"", buf.as_slice());
}
// The buffer provided by the client is too small: the BOM is still read successfully.
{
    const BYTES: &'static [u8] = b"\xEF\xBB\xBFThis stream starts with a UTF-8 BOM.";
    let mut reader = SkipEncodingBom::new(BomType::all(), Cursor::new(BYTES));
    let mut buf = [0u8; 2];
    let _ = reader.read(&mut buf).unwrap();
    assert_eq!(Some(Some(skip_bom::BomType::UTF8)), reader.bom_found());
    assert_eq!(b"Th", buf.as_slice());
}

pub fn into_inner(self) -> R

Unwraps this SkipEncodingBom<R>, returning the underlying reader.

pub fn get_ref(&self) -> &R

Get a shared reference to the underlying reader.

pub fn get_mut(&mut self) -> &mut R

Get a mutable reference to the underlying reader.

Trait Implementations

impl<'a, R: Clone + Read> Clone for SkipEncodingBom<'a, R>

fn clone(&self) -> SkipEncodingBom<'a, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, R: Debug + Read> Debug for SkipEncodingBom<'a, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, R: Read> Read for SkipEncodingBom<'a, R>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.