src/new.rs - platform/external/rust/crates/byteorder - Git at Google

 use std::error;
 use std::fmt;
 use std::io;
 use std::result;

 use ByteOrder;

 /// A short-hand for `result::Result<T, byteorder::Error>`.
 pub type Result<T> = result::Result<T, Error>;

 /// An error type for reading bytes.
 ///
 /// This is a thin wrapper over the standard `io::Error` type. Namely, it
 /// adds one additional error case: an unexpected EOF.
 ///
 /// Note that this error is also used for the `write` methods to keep things
 /// consistent.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Error {
     /// An unexpected EOF.
     ///
     /// This occurs when a call to the underlying reader returns `0` bytes,
     /// but more bytes are required to decode a meaningful value.
     UnexpectedEOF,
     /// Any underlying IO error that occurs while reading bytes.
     Io(io::Error),
 }

 impl error::FromError<io::Error> for Error {
     fn from_error(err: io::Error) -> Error { Error::Io(err) }
 }

 impl error::FromError<Error> for io::Error {
     fn from_error(err: Error) -> io::Error {
         match err {
             Error::Io(err) => err,
             Error::UnexpectedEOF => io::Error::new(io::ErrorKind::Other,
                                                    "unexpected EOF", None)
         }
     }
 }

 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Error::UnexpectedEOF => write!(f, "Unexpected end of file."),
             Error::Io(ref err) => err.fmt(f),
         }
     }
 }

 impl error::Error for Error {
     fn description(&self) -> &str {
         match *self {
             Error::UnexpectedEOF => "Unexpected end of file.",
             Error::Io(ref err) => err.description(),
         }
     }

     fn cause(&self) -> Option<&error::Error> {
         match *self {
             Error::UnexpectedEOF => None,
             Error::Io(ref err) => err.cause(),
         }
     }
 }

 /// Extends `Read` with methods for reading numbers. (For `std::io`.)
 ///
 /// Most of the methods defined here have an unconstrained type parameter that
 /// must be explicitly instantiated. Typically, it is instantiated with either
 /// the `BigEndian` or `LittleEndian` types defined in this crate.
 ///
 /// # Examples
 ///
 /// Read unsigned 16 bit big-endian integers from a `Read`:
 ///
 /// ```rust
 /// use std::io::Cursor;
 /// use byteorder::{BigEndian, ReadBytesExt};
 ///
 /// let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
 /// assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
 /// assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
 /// ```
 pub trait ReadBytesExt: io::Read {
     /// Reads an unsigned 8 bit integer from the underlying reader.
     ///
     /// Note that since this reads a single byte, no byte order conversions
     /// are used. It is included for completeness.
     fn read_u8(&mut self) -> Result<u8> {
         let mut buf = [0; 1];
         try!(read_full(self, &mut buf));
         Ok(buf[0])
     }

     /// Reads a signed 8 bit integer from the underlying reader.
     ///
     /// Note that since this reads a single byte, no byte order conversions
     /// are used. It is included for completeness.
     fn read_i8(&mut self) -> Result<i8> {
         let mut buf = [0; 1];
         try!(read_full(self, &mut buf));
         Ok(buf[0] as i8)
     }

     /// Reads an unsigned 16 bit integer from the underlying reader.
     fn read_u16<T: ByteOrder>(&mut self) -> Result<u16> {
         let mut buf = [0; 2];
         try!(read_full(self, &mut buf));
         Ok(<T as ByteOrder>::read_u16(&buf))
     }

     /// Reads a signed 16 bit integer from the underlying reader.
     fn read_i16<T: ByteOrder>(&mut self) -> Result<i16> {
         let mut buf = [0; 2];
         try!(read_full(self, &mut buf));
         Ok(<T as ByteOrder>::read_i16(&buf))
     }

     /// Reads an unsigned 32 bit integer from the underlying reader.
     fn read_u32<T: ByteOrder>(&mut self) -> Result<u32> {
         let mut buf = [0; 4];
         try!(read_full(self, &mut buf));
         Ok(<T as ByteOrder>::read_u32(&buf))
     }

     /// Reads a signed 32 bit integer from the underlying reader.
     fn read_i32<T: ByteOrder>(&mut self) -> Result<i32> {
         let mut buf = [0; 4];
         try!(read_full(self, &mut buf));
         Ok(<T as ByteOrder>::read_i32(&buf))
     }

     /// Reads an unsigned 64 bit integer from the underlying reader.
     fn read_u64<T: ByteOrder>(&mut self) -> Result<u64> {
         let mut buf = [0; 8];
         try!(read_full(self, &mut buf));
         Ok(<T as ByteOrder>::read_u64(&buf))
     }

     /// Reads a signed 64 bit integer from the underlying reader.
     fn read_i64<T: ByteOrder>(&mut self) -> Result<i64> {
         let mut buf = [0; 8];
         try!(read_full(self, &mut buf));
         Ok(<T as ByteOrder>::read_i64(&buf))
     }

     /// Reads an unsigned n-bytes integer from the underlying reader.
     fn read_uint<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u64> {
         let mut buf = [0; 8];
         try!(read_full(self, &mut buf[0..nbytes]));
         Ok(<T as ByteOrder>::read_uint(&buf, nbytes))
     }

     /// Reads a signed n-bytes integer from the underlying reader.
     fn read_int<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i64> {
         let mut buf = [0; 8];
         try!(read_full(self, &mut buf[0..nbytes]));
         Ok(<T as ByteOrder>::read_int(&buf, nbytes))
     }

     /// Reads a IEEE754 single-precision (4 bytes) floating point number from
     /// the underlying reader.
     fn read_f32<T: ByteOrder>(&mut self) -> Result<f32> {
         let mut buf = [0; 4];
         try!(read_full(self, &mut buf));
         Ok(<T as ByteOrder>::read_f32(&buf))
     }

     /// Reads a IEEE754 double-precision (8 bytes) floating point number from
     /// the underlying reader.
     fn read_f64<T: ByteOrder>(&mut self) -> Result<f64> {
         let mut buf = [0; 8];
         try!(read_full(self, &mut buf));
         Ok(<T as ByteOrder>::read_f64(&buf))
     }
 }

 /// All types that implement `Read` get methods defined in `ReadBytesExt`
 /// for free.
 impl<R: io::Read> ReadBytesExt for R {}

 fn read_full<R: io::Read + ?Sized>(rdr: &mut R, buf: &mut [u8]) -> Result<()> {
     let mut nread = 0usize;
     while nread < buf.len() {
         match rdr.read(&mut buf[nread..]) {
             Ok(0) => return Err(Error::UnexpectedEOF),
             Ok(n) => nread += n,
             Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {},
             Err(e) => return Err(error::FromError::from_error(e))
         }
     }
     Ok(())
 }

 fn write_all<W: io::Write + ?Sized>(wtr: &mut W, buf: &[u8]) -> Result<()> {
     wtr.write_all(buf).map_err(error::FromError::from_error)
 }

 /// Extends `Write` with methods for writing numbers. (For `std::io`.)
 ///
 /// Most of the methods defined here have an unconstrained type parameter that
 /// must be explicitly instantiated. Typically, it is instantiated with either
 /// the `BigEndian` or `LittleEndian` types defined in this crate.
 ///
 /// # Examples
 ///
 /// Write unsigned 16 bit big-endian integers to a `Write`:
 ///
 /// ```rust
 /// use byteorder::{BigEndian, WriteBytesExt};
 ///
 /// let mut wtr = vec![];
 /// wtr.write_u16::<BigEndian>(517).unwrap();
 /// wtr.write_u16::<BigEndian>(768).unwrap();
 /// assert_eq!(wtr, vec![2, 5, 3, 0]);
 /// ```
 pub trait WriteBytesExt: io::Write {
     /// Writes an unsigned 8 bit integer to the underlying writer.
     ///
     /// Note that since this writes a single byte, no byte order conversions
     /// are used. It is included for completeness.
     fn write_u8(&mut self, n: u8) -> Result<()> {
         write_all(self, &[n])
     }

     /// Writes a signed 8 bit integer to the underlying writer.
     ///
     /// Note that since this writes a single byte, no byte order conversions
     /// are used. It is included for completeness.
     fn write_i8(&mut self, n: i8) -> Result<()> {
         write_all(self, &[n as u8])
     }

     /// Writes an unsigned 16 bit integer to the underlying writer.
     fn write_u16<T: ByteOrder>(&mut self, n: u16) -> Result<()> {
         let mut buf = [0; 2];
         <T as ByteOrder>::write_u16(&mut buf, n);
         write_all(self, &buf)
     }

     /// Writes a signed 16 bit integer to the underlying writer.
     fn write_i16<T: ByteOrder>(&mut self, n: i16) -> Result<()> {
         let mut buf = [0; 2];
         <T as ByteOrder>::write_i16(&mut buf, n);
         write_all(self, &buf)
     }

     /// Writes an unsigned 32 bit integer to the underlying writer.
     fn write_u32<T: ByteOrder>(&mut self, n: u32) -> Result<()> {
         let mut buf = [0; 4];
         <T as ByteOrder>::write_u32(&mut buf, n);
         write_all(self, &buf)
     }

     /// Writes a signed 32 bit integer to the underlying writer.
     fn write_i32<T: ByteOrder>(&mut self, n: i32) -> Result<()> {
         let mut buf = [0; 4];
         <T as ByteOrder>::write_i32(&mut buf, n);
         write_all(self, &buf)
     }

     /// Writes an unsigned 64 bit integer to the underlying writer.
     fn write_u64<T: ByteOrder>(&mut self, n: u64) -> Result<()> {
         let mut buf = [0; 8];
         <T as ByteOrder>::write_u64(&mut buf, n);
         write_all(self, &buf)
     }

     /// Writes a signed 64 bit integer to the underlying writer.
     fn write_i64<T: ByteOrder>(&mut self, n: i64) -> Result<()> {
         let mut buf = [0; 8];
         <T as ByteOrder>::write_i64(&mut buf, n);
         write_all(self, &buf)
     }

     /// Writes a IEEE754 single-precision (4 bytes) floating point number to
     /// the underlying writer.
     fn write_f32<T: ByteOrder>(&mut self, n: f32) -> Result<()> {
         let mut buf = [0; 4];
         <T as ByteOrder>::write_f32(&mut buf, n);
         write_all(self, &buf)
     }

     /// Writes a IEEE754 double-precision (8 bytes) floating point number to
     /// the underlying writer.
     fn write_f64<T: ByteOrder>(&mut self, n: f64) -> Result<()> {
         let mut buf = [0; 8];
         <T as ByteOrder>::write_f64(&mut buf, n);
         write_all(self, &buf)
     }
 }

 /// All types that implement `Write` get methods defined in `WriteBytesExt`
 /// for free.
 impl<W: io::Write> WriteBytesExt for W {}
	use std::error;
	use std::fmt;
	use std::io;
	use std::result;

	use ByteOrder;

	/// A short-hand for `result::Result<T, byteorder::Error>`.
	pub type Result<T> = result::Result<T, Error>;

	/// An error type for reading bytes.
	///
	/// This is a thin wrapper over the standard `io::Error` type. Namely, it
	/// adds one additional error case: an unexpected EOF.
	///
	/// Note that this error is also used for the `write` methods to keep things
	/// consistent.
	#[derive(Clone, Debug, Eq, PartialEq)]
	pub enum Error {
	/// An unexpected EOF.
	///
	/// This occurs when a call to the underlying reader returns `0` bytes,
	/// but more bytes are required to decode a meaningful value.
	UnexpectedEOF,
	/// Any underlying IO error that occurs while reading bytes.
	Io(io::Error),
	}

	impl error::FromError<io::Error> for Error {
	fn from_error(err: io::Error) -> Error { Error::Io(err) }
	}

	impl error::FromError<Error> for io::Error {
	fn from_error(err: Error) -> io::Error {
	match err {
	Error::Io(err) => err,
	Error::UnexpectedEOF => io::Error::new(io::ErrorKind::Other,
	"unexpected EOF", None)
	}
	}
	}

	impl fmt::Display for Error {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	match *self {
	Error::UnexpectedEOF => write!(f, "Unexpected end of file."),
	Error::Io(ref err) => err.fmt(f),
	}
	}
	}

	impl error::Error for Error {
	fn description(&self) -> &str {
	match *self {
	Error::UnexpectedEOF => "Unexpected end of file.",
	Error::Io(ref err) => err.description(),
	}
	}

	fn cause(&self) -> Option<&error::Error> {
	match *self {
	Error::UnexpectedEOF => None,
	Error::Io(ref err) => err.cause(),
	}
	}
	}

	/// Extends `Read` with methods for reading numbers. (For `std::io`.)
	///
	/// Most of the methods defined here have an unconstrained type parameter that
	/// must be explicitly instantiated. Typically, it is instantiated with either
	/// the `BigEndian` or `LittleEndian` types defined in this crate.
	///
	/// # Examples
	///
	/// Read unsigned 16 bit big-endian integers from a `Read`:
	///
	/// ```rust
	/// use std::io::Cursor;
	/// use byteorder::{BigEndian, ReadBytesExt};
	///
	/// let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
	/// assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
	/// assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());
	/// ```
	pub trait ReadBytesExt: io::Read {
	/// Reads an unsigned 8 bit integer from the underlying reader.
	///
	/// Note that since this reads a single byte, no byte order conversions
	/// are used. It is included for completeness.
	fn read_u8(&mut self) -> Result<u8> {
	let mut buf = [0; 1];
	try!(read_full(self, &mut buf));
	Ok(buf[0])
	}

	/// Reads a signed 8 bit integer from the underlying reader.
	///
	/// Note that since this reads a single byte, no byte order conversions
	/// are used. It is included for completeness.
	fn read_i8(&mut self) -> Result<i8> {
	let mut buf = [0; 1];
	try!(read_full(self, &mut buf));
	Ok(buf[0] as i8)
	}

	/// Reads an unsigned 16 bit integer from the underlying reader.
	fn read_u16<T: ByteOrder>(&mut self) -> Result<u16> {
	let mut buf = [0; 2];
	try!(read_full(self, &mut buf));
	Ok(<T as ByteOrder>::read_u16(&buf))
	}

	/// Reads a signed 16 bit integer from the underlying reader.
	fn read_i16<T: ByteOrder>(&mut self) -> Result<i16> {
	let mut buf = [0; 2];
	try!(read_full(self, &mut buf));
	Ok(<T as ByteOrder>::read_i16(&buf))
	}

	/// Reads an unsigned 32 bit integer from the underlying reader.
	fn read_u32<T: ByteOrder>(&mut self) -> Result<u32> {
	let mut buf = [0; 4];
	try!(read_full(self, &mut buf));
	Ok(<T as ByteOrder>::read_u32(&buf))
	}

	/// Reads a signed 32 bit integer from the underlying reader.
	fn read_i32<T: ByteOrder>(&mut self) -> Result<i32> {
	let mut buf = [0; 4];
	try!(read_full(self, &mut buf));
	Ok(<T as ByteOrder>::read_i32(&buf))
	}

	/// Reads an unsigned 64 bit integer from the underlying reader.
	fn read_u64<T: ByteOrder>(&mut self) -> Result<u64> {
	let mut buf = [0; 8];
	try!(read_full(self, &mut buf));
	Ok(<T as ByteOrder>::read_u64(&buf))
	}

	/// Reads a signed 64 bit integer from the underlying reader.
	fn read_i64<T: ByteOrder>(&mut self) -> Result<i64> {
	let mut buf = [0; 8];
	try!(read_full(self, &mut buf));
	Ok(<T as ByteOrder>::read_i64(&buf))
	}

	/// Reads an unsigned n-bytes integer from the underlying reader.
	fn read_uint<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u64> {
	let mut buf = [0; 8];
	try!(read_full(self, &mut buf[0..nbytes]));
	Ok(<T as ByteOrder>::read_uint(&buf, nbytes))
	}

	/// Reads a signed n-bytes integer from the underlying reader.
	fn read_int<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i64> {
	let mut buf = [0; 8];
	try!(read_full(self, &mut buf[0..nbytes]));
	Ok(<T as ByteOrder>::read_int(&buf, nbytes))
	}

	/// Reads a IEEE754 single-precision (4 bytes) floating point number from
	/// the underlying reader.
	fn read_f32<T: ByteOrder>(&mut self) -> Result<f32> {
	let mut buf = [0; 4];
	try!(read_full(self, &mut buf));
	Ok(<T as ByteOrder>::read_f32(&buf))
	}

	/// Reads a IEEE754 double-precision (8 bytes) floating point number from
	/// the underlying reader.
	fn read_f64<T: ByteOrder>(&mut self) -> Result<f64> {
	let mut buf = [0; 8];
	try!(read_full(self, &mut buf));
	Ok(<T as ByteOrder>::read_f64(&buf))
	}
	}

	/// All types that implement `Read` get methods defined in `ReadBytesExt`
	/// for free.
	impl<R: io::Read> ReadBytesExt for R {}

	fn read_full<R: io::Read + ?Sized>(rdr: &mut R, buf: &mut [u8]) -> Result<()> {
	let mut nread = 0usize;
	while nread < buf.len() {
	match rdr.read(&mut buf[nread..]) {
	Ok(0) => return Err(Error::UnexpectedEOF),
	Ok(n) => nread += n,
	Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {},
	Err(e) => return Err(error::FromError::from_error(e))
	}
	}
	Ok(())
	}

	fn write_all<W: io::Write + ?Sized>(wtr: &mut W, buf: &[u8]) -> Result<()> {
	wtr.write_all(buf).map_err(error::FromError::from_error)
	}

	/// Extends `Write` with methods for writing numbers. (For `std::io`.)
	///
	/// Most of the methods defined here have an unconstrained type parameter that
	/// must be explicitly instantiated. Typically, it is instantiated with either
	/// the `BigEndian` or `LittleEndian` types defined in this crate.
	///
	/// # Examples
	///
	/// Write unsigned 16 bit big-endian integers to a `Write`:
	///
	/// ```rust
	/// use byteorder::{BigEndian, WriteBytesExt};
	///
	/// let mut wtr = vec![];
	/// wtr.write_u16::<BigEndian>(517).unwrap();
	/// wtr.write_u16::<BigEndian>(768).unwrap();
	/// assert_eq!(wtr, vec![2, 5, 3, 0]);
	/// ```
	pub trait WriteBytesExt: io::Write {
	/// Writes an unsigned 8 bit integer to the underlying writer.
	///
	/// Note that since this writes a single byte, no byte order conversions
	/// are used. It is included for completeness.
	fn write_u8(&mut self, n: u8) -> Result<()> {
	write_all(self, &[n])
	}

	/// Writes a signed 8 bit integer to the underlying writer.
	///
	/// Note that since this writes a single byte, no byte order conversions
	/// are used. It is included for completeness.
	fn write_i8(&mut self, n: i8) -> Result<()> {
	write_all(self, &[n as u8])
	}

	/// Writes an unsigned 16 bit integer to the underlying writer.
	fn write_u16<T: ByteOrder>(&mut self, n: u16) -> Result<()> {
	let mut buf = [0; 2];
	<T as ByteOrder>::write_u16(&mut buf, n);
	write_all(self, &buf)
	}

	/// Writes a signed 16 bit integer to the underlying writer.
	fn write_i16<T: ByteOrder>(&mut self, n: i16) -> Result<()> {
	let mut buf = [0; 2];
	<T as ByteOrder>::write_i16(&mut buf, n);
	write_all(self, &buf)
	}

	/// Writes an unsigned 32 bit integer to the underlying writer.
	fn write_u32<T: ByteOrder>(&mut self, n: u32) -> Result<()> {
	let mut buf = [0; 4];
	<T as ByteOrder>::write_u32(&mut buf, n);
	write_all(self, &buf)
	}

	/// Writes a signed 32 bit integer to the underlying writer.
	fn write_i32<T: ByteOrder>(&mut self, n: i32) -> Result<()> {
	let mut buf = [0; 4];
	<T as ByteOrder>::write_i32(&mut buf, n);
	write_all(self, &buf)
	}

	/// Writes an unsigned 64 bit integer to the underlying writer.
	fn write_u64<T: ByteOrder>(&mut self, n: u64) -> Result<()> {
	let mut buf = [0; 8];
	<T as ByteOrder>::write_u64(&mut buf, n);
	write_all(self, &buf)
	}

	/// Writes a signed 64 bit integer to the underlying writer.
	fn write_i64<T: ByteOrder>(&mut self, n: i64) -> Result<()> {
	let mut buf = [0; 8];
	<T as ByteOrder>::write_i64(&mut buf, n);
	write_all(self, &buf)
	}

	/// Writes a IEEE754 single-precision (4 bytes) floating point number to
	/// the underlying writer.
	fn write_f32<T: ByteOrder>(&mut self, n: f32) -> Result<()> {
	let mut buf = [0; 4];
	<T as ByteOrder>::write_f32(&mut buf, n);
	write_all(self, &buf)
	}

	/// Writes a IEEE754 double-precision (8 bytes) floating point number to
	/// the underlying writer.
	fn write_f64<T: ByteOrder>(&mut self, n: f64) -> Result<()> {
	let mut buf = [0; 8];
	<T as ByteOrder>::write_f64(&mut buf, n);
	write_all(self, &buf)
	}
	}

	/// All types that implement `Write` get methods defined in `WriteBytesExt`
	/// for free.
	impl<W: io::Write> WriteBytesExt for W {}