use std::fmt::{self, Display, Formatter};
use std::fs::File;
use std::io::{Error, ErrorKind, Read};
use std::str::FromStr;
#[cfg(test)]
mod test;
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Bom {
Null,
Bocu1,
Gb18030,
Scsu,
UtfEbcdic,
Utf1,
Utf7,
Utf8,
Utf16Be,
Utf16Le,
Utf32Be,
Utf32Le,
}
impl Bom {
pub fn len(&self) -> usize {
match *self {
Bom::Null => 0,
Bom::Bocu1 => 3,
Bom::Gb18030 => 4,
Bom::Scsu => 3,
Bom::UtfEbcdic => 4,
Bom::Utf1 => 3,
Bom::Utf7 => 4,
Bom::Utf8 => 3,
Bom::Utf16Be => 2,
Bom::Utf16Le => 2,
Bom::Utf32Be => 4,
Bom::Utf32Le => 4,
}
}
}
impl AsRef<str> for Bom {
fn as_ref(&self) -> &str {
match *self {
Bom::Null => "[not set]",
Bom::Bocu1 => "BOCU-1",
Bom::Gb18030 => "GB 18030",
Bom::Scsu => "SCSU",
Bom::UtfEbcdic => "UTF-EBCDIC",
Bom::Utf1 => "UTF-1",
Bom::Utf7 => "UTF-7",
Bom::Utf8 => "UTF-8",
Bom::Utf16Be => "UTF-16 (big-endian)",
Bom::Utf16Le => "UTF-16 (little-endian)",
Bom::Utf32Be => "UTF-32 (big-endian)",
Bom::Utf32Le => "UTF-32 (little-endian)",
}
}
}
impl AsRef<[u8]> for Bom {
fn as_ref(&self) -> &[u8] {
match *self {
Bom::Null => &[],
Bom::Bocu1 => &[0xfb, 0xee, 0x28],
Bom::Gb18030 => &[0x84, 0x31, 0x95, 0x33],
Bom::Scsu => &[0x0e, 0xfe, 0xff],
Bom::UtfEbcdic => &[0xdd, 0x73, 0x66, 0x73],
Bom::Utf1 => &[0xf7, 0x64, 0x4c],
Bom::Utf7 => &[0x2b, 0x2f, 0x76],
Bom::Utf8 => &[0xef, 0xbb, 0xbf],
Bom::Utf16Be => &[0xfe, 0xff],
Bom::Utf16Le => &[0xff, 0xfe],
Bom::Utf32Be => &[0, 0, 0xfe, 0xff],
Bom::Utf32Le => &[0xff, 0xfe, 0, 0],
}
}
}
impl Default for Bom {
fn default() -> Self {
Bom::Null
}
}
impl Display for Bom {
fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
write!(formatter, "{}", AsRef::<str>::as_ref(self))
}
}
impl Eq for Bom {}
macro_rules! compare_tail {
($slice:ident, $bytes:expr) => {
compare_tail!($slice, $bytes, 1)
};
($slice:ident, $bytes:expr, $from:expr) => {
compare_tail!($slice, $bytes.len() + $from, $bytes, $from)
};
($slice:ident, $len:expr, $bytes:expr, $from:expr) => {
$slice.len() >= $len && $slice[$from..$from + $bytes.len()] == $bytes
};
}
impl From<&[u8]> for Bom {
fn from(slice: &[u8]) -> Self {
if slice.len() >= 2 {
match slice[0] {
0 => {
if compare_tail!(slice, [0, 0xfe, 0xff]) {
return Bom::Utf32Be;
}
}
0x0e => {
if compare_tail!(slice, [0xfe, 0xff]) {
return Bom::Scsu;
}
}
0x2b => {
if compare_tail!(slice, 4, [0x2f, 0x76], 1)
&& (slice[3] == 0x38
|| slice[3] == 0x39
|| slice[3] == 0x2b
|| slice[3] == 0x2f)
{
return Bom::Utf7;
}
}
0x84 => {
if compare_tail!(slice, [0x31, 0x95, 0x33]) {
return Bom::Gb18030;
}
}
0xdd => {
if compare_tail!(slice, [0x73, 0x66, 0x73]) {
return Bom::UtfEbcdic;
}
}
0xef => {
if compare_tail!(slice, [0xbb, 0xbf]) {
return Bom::Utf8;
}
}
0xf7 => {
if compare_tail!(slice, [0x64, 0x4c]) {
return Bom::Utf1;
}
}
0xfb => {
if compare_tail!(slice, [0xee, 0x28]) {
return Bom::Bocu1;
}
}
0xfe => {
if slice[1] == 0xff {
return Bom::Utf16Be;
}
}
0xff => {
if slice[1] == 0xfe {
if compare_tail!(slice, [0, 0], 2) {
return Bom::Utf32Le;
}
return Bom::Utf16Le;
}
}
_ => {}
}
}
Bom::Null
}
}
impl From<&mut File> for Bom {
fn from(file: &mut File) -> Self {
let mut data = [0u8; 4];
let mut result = file.read_exact(&mut data);
if let Err(ref error) = result {
if error.kind() == ErrorKind::UnexpectedEof {
let short_data = [0u8; 3];
result = file.read_exact(&mut data);
if let Err(ref error) = result {
if error.kind() == ErrorKind::UnexpectedEof {
let short_data = [0u8; 2];
result = file.read_exact(&mut data);
data[0] = short_data[0];
data[1] = short_data[1];
}
} else {
data[0] = short_data[0];
data[1] = short_data[1];
data[2] = short_data[2];
}
}
}
if result.is_ok() {
Bom::from(&data[0..])
} else {
Bom::Null
}
}
}
impl FromStr for Bom {
type Err = Error;
fn from_str(path: &str) -> Result<Self, Self::Err> {
let mut file = File::open(path)?;
Ok(Bom::from(&mut file))
}
}