use crate::io::prelude::*;
use crate::cmp;
-use crate::io::{self, Initializer, SeekFrom, Error, ErrorKind, IoSlice, IoSliceMut};
+use crate::io::{self, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, SeekFrom};
use core::convert::TryInto;
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct Cursor<T> {
inner: T,
pos: u64,
/// let vec = buff.into_inner();
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn into_inner(self) -> T { self.inner }
+ pub fn into_inner(self) -> T {
+ self.inner
+ }
/// Gets a reference to the underlying value in this cursor.
///
/// let reference = buff.get_ref();
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get_ref(&self) -> &T { &self.inner }
+ pub fn get_ref(&self) -> &T {
+ &self.inner
+ }
/// Gets a mutable reference to the underlying value in this cursor.
///
/// let reference = buff.get_mut();
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
+ pub fn get_mut(&mut self) -> &mut T {
+ &mut self.inner
+ }
/// Returns the current position of this cursor.
///
/// assert_eq!(buff.position(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn position(&self) -> u64 { self.pos }
+ pub fn position(&self) -> u64 {
+ self.pos
+ }
/// Sets the position of this cursor.
///
/// assert_eq!(buff.position(), 4);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
+ pub fn set_position(&mut self, pos: u64) {
+ self.pos = pos;
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
+impl<T> io::Seek for Cursor<T>
+where
+ T: AsRef<[u8]>,
+{
fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
let (base_pos, offset) = match style {
- SeekFrom::Start(n) => { self.pos = n; return Ok(n); }
+ SeekFrom::Start(n) => {
+ self.pos = n;
+ return Ok(n);
+ }
SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
SeekFrom::Current(n) => (self.pos, n),
};
base_pos.checked_sub((offset.wrapping_neg()) as u64)
};
match new_pos {
- Some(n) => {self.pos = n; Ok(self.pos)}
- None => Err(Error::new(ErrorKind::InvalidInput,
- "invalid seek to a negative or overflowing position"))
+ Some(n) => {
+ self.pos = n;
+ Ok(self.pos)
+ }
+ None => Err(Error::new(
+ ErrorKind::InvalidInput,
+ "invalid seek to a negative or overflowing position",
+ )),
}
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
+impl<T> Read for Cursor<T>
+where
+ T: AsRef<[u8]>,
+{
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let n = Read::read(&mut self.fill_buf()?, buf)?;
self.pos += n as u64;
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
+impl<T> BufRead for Cursor<T>
+where
+ T: AsRef<[u8]>,
+{
fn fill_buf(&mut self) -> io::Result<&[u8]> {
let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
Ok(&self.inner.as_ref()[(amt as usize)..])
}
- fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
+ fn consume(&mut self, amt: usize) {
+ self.pos += amt as u64;
+ }
}
// Non-resizing write implementation
pos_mut: &mut u64,
slice: &mut [u8],
bufs: &[IoSlice<'_>],
-) -> io::Result<usize>
-{
+) -> io::Result<usize> {
let mut nwritten = 0;
for buf in bufs {
let n = slice_write(pos_mut, slice, buf)?;
// Resizing write implementation
fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
let pos: usize = (*pos_mut).try_into().map_err(|_| {
- Error::new(ErrorKind::InvalidInput,
- "cursor position exceeds maximum possible vector length")
+ Error::new(
+ ErrorKind::InvalidInput,
+ "cursor position exceeds maximum possible vector length",
+ )
})?;
// Make sure the internal buffer is as least as big as where we
// currently are
pos_mut: &mut u64,
vec: &mut Vec<u8>,
bufs: &[IoSlice<'_>],
-) -> io::Result<usize>
-{
+) -> io::Result<usize> {
let mut nwritten = 0;
for buf in bufs {
nwritten += vec_write(pos_mut, vec, buf)?;
}
#[inline]
- fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
}
#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
}
#[inline]
- fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
}
#[inline]
- fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
}
#[stable(feature = "cursor_box_slice", since = "1.5.0")]
}
#[inline]
- fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
}
#[cfg(test)]
mod tests {
use crate::io::prelude::*;
- use crate::io::{Cursor, SeekFrom, IoSlice, IoSliceMut};
+ use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
#[test]
fn test_vec_writer() {
assert_eq!(writer.write(&[0]).unwrap(), 1);
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
- assert_eq!(writer.write_vectored(
- &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
- ).unwrap(), 3);
+ assert_eq!(
+ writer
+ .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
+ .unwrap(),
+ 3
+ );
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(writer, b);
}
assert_eq!(writer.write(&[0]).unwrap(), 1);
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
- assert_eq!(writer.write_vectored(
- &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
- ).unwrap(), 3);
+ assert_eq!(
+ writer
+ .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
+ .unwrap(),
+ 3
+ );
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(&writer.get_ref()[..], b);
}
assert_eq!(writer.write(&[0]).unwrap(), 1);
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
- assert_eq!(writer.write_vectored(
- &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
- ).unwrap(), 3);
+ assert_eq!(
+ writer
+ .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
+ .unwrap(),
+ 3
+ );
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(&writer.get_ref()[..], b);
}
assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
assert_eq!(writer.position(), 1);
assert_eq!(
- writer.write_vectored(&[
- IoSlice::new(&[1, 2, 3]),
- IoSlice::new(&[4, 5, 6, 7]),
- ]).unwrap(),
+ writer
+ .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),])
+ .unwrap(),
7,
);
assert_eq!(writer.position(), 8);
assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
assert_eq!(writer.position(), 1);
assert_eq!(
- writer.write_vectored(
- &[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],
- ).unwrap(),
+ writer
+ .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
+ .unwrap(),
7,
);
assert_eq!(writer.position(), 8);
assert_eq!(writer.position(), 7);
assert_eq!(writer.write(&[4]).unwrap(), 1);
assert_eq!(writer.position(), 8);
-
}
let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
assert_eq!(buf, b);
assert_eq!(reader.position(), 0);
let mut buf = [0];
assert_eq!(
- reader.read_vectored(&mut [
- IoSliceMut::new(&mut []),
- IoSliceMut::new(&mut buf),
- ]).unwrap(),
+ reader
+ .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
+ .unwrap(),
1,
);
assert_eq!(reader.position(), 1);
let mut buf1 = [0; 4];
let mut buf2 = [0; 4];
assert_eq!(
- reader.read_vectored(&mut [
- IoSliceMut::new(&mut buf1),
- IoSliceMut::new(&mut buf2),
- ]).unwrap(),
+ reader
+ .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
+ .unwrap(),
7,
);
let b1: &[_] = &[1, 2, 3, 4];
assert_eq!(reader.position(), 0);
let mut buf = [0];
assert_eq!(
- reader.read_vectored(&mut [
- IoSliceMut::new(&mut []),
- IoSliceMut::new(&mut buf),
- ]).unwrap(),
+ reader
+ .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
+ .unwrap(),
1,
);
assert_eq!(reader.position(), 1);
let mut buf1 = [0; 4];
let mut buf2 = [0; 4];
assert_eq!(
- reader.read_vectored(
- &mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],
- ).unwrap(),
+ reader
+ .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
+ .unwrap(),
7,
);
let b1: &[_] = &[1, 2, 3, 4];
assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
let mut buf = [0];
assert_eq!(
- reader.read_vectored(&mut [
- IoSliceMut::new(&mut []),
- IoSliceMut::new(&mut buf),
- ]).unwrap(),
+ reader
+ .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
+ .unwrap(),
1,
);
assert_eq!(reader.len(), 7);
let mut buf1 = [0; 4];
let mut buf2 = [0; 4];
assert_eq!(
- reader.read_vectored(
- &mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],
- ).unwrap(),
+ reader
+ .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
+ .unwrap(),
7,
);
let b1: &[_] = &[1, 2, 3, 4];
c.set_position(<usize>::max_value() as u64 + 1);
assert!(c.write_all(&[1, 2, 3]).is_err());
}
+
+ #[test]
+ fn test_partial_eq() {
+ assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
+ }
+
+ #[test]
+ fn test_eq() {
+ struct AssertEq<T: Eq>(pub T);
+
+ let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
+ }
}