sgx_tstd/src/io/cursor.rs - incubator-teaclave-sgx-sdk - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License..

 use crate::io::prelude::*;

 use crate::cmp;
 use crate::io::{self, ErrorKind, IoSlice, IoSliceMut, ReadBuf, SeekFrom};

 use core::convert::TryInto;

 /// A `Cursor` wraps an in-memory buffer and provides it with a
 /// [`Seek`] implementation.
 ///
 /// `Cursor`s are used with in-memory buffers, anything implementing
 /// <code>[AsRef]<\[u8]></code>, to allow them to implement [`Read`] and/or [`Write`],
 /// allowing these buffers to be used anywhere you might use a reader or writer
 /// that does actual I/O.
 ///
 /// The standard library implements some I/O traits on various types which
 /// are commonly used as a buffer, like <code>Cursor<[Vec]\<u8>></code> and
 /// <code>Cursor<[&\[u8\]][bytes]></code>.
 ///
 /// # Examples
 ///
 /// We may want to write bytes to a [`File`] in our production
 /// code, but use an in-memory buffer in our tests. We can do this with
 /// `Cursor`:
 ///
 /// [bytes]: crate::slice "slice"
 /// [`File`]: crate::fs::File
 ///
 /// ```no_run
 /// use std::io::prelude::*;
 /// use std::io::{self, SeekFrom};
 /// use std::fs::File;
 ///
 /// // a library function we've written
 /// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
 ///     writer.seek(SeekFrom::End(-10))?;
 ///
 ///     for i in 0..10 {
 ///         writer.write(&[i])?;
 ///     }
 ///
 ///     // all went well
 ///     Ok(())
 /// }
 ///
 /// # fn foo() -> io::Result<()> {
 /// // Here's some code that uses this library function.
 /// //
 /// // We might want to use a BufReader here for efficiency, but let's
 /// // keep this example focused.
 /// let mut file = File::create("foo.txt")?;
 ///
 /// write_ten_bytes_at_end(&mut file)?;
 /// # Ok(())
 /// # }
 ///
 /// // now let's write a test
 /// #[test]
 /// fn test_writes_bytes() {
 ///     // setting up a real File is much slower than an in-memory buffer,
 ///     // let's use a cursor instead
 ///     use std::io::Cursor;
 ///     let mut buff = Cursor::new(vec![0; 15]);
 ///
 ///     write_ten_bytes_at_end(&mut buff).unwrap();
 ///
 ///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
 /// }
 /// ```
 #[derive(Debug, Default, Eq, PartialEq)]
 pub struct Cursor<T> {
     inner: T,
     pos: u64,
 }

 impl<T> Cursor<T> {
     /// Creates a new cursor wrapping the provided underlying in-memory buffer.
     ///
     /// Cursor initial position is `0` even if underlying buffer (e.g., [`Vec`])
     /// is not empty. So writing to cursor starts with overwriting [`Vec`]
     /// content, not with appending to it.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::io::Cursor;
     ///
     /// let buff = Cursor::new(Vec::new());
     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
     /// # force_inference(&buff);
     /// ```
     pub const fn new(inner: T) -> Cursor<T> {
         Cursor { pos: 0, inner }
     }

     /// Consumes this cursor, returning the underlying value.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::io::Cursor;
     ///
     /// let buff = Cursor::new(Vec::new());
     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
     /// # force_inference(&buff);
     ///
     /// let vec = buff.into_inner();
     /// ```
     pub fn into_inner(self) -> T {
         self.inner
     }

     /// Gets a reference to the underlying value in this cursor.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::io::Cursor;
     ///
     /// let buff = Cursor::new(Vec::new());
     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
     /// # force_inference(&buff);
     ///
     /// let reference = buff.get_ref();
     /// ```
     pub const fn get_ref(&self) -> &T {
         &self.inner
     }

     /// Gets a mutable reference to the underlying value in this cursor.
     ///
     /// Care should be taken to avoid modifying the internal I/O state of the
     /// underlying value as it may corrupt this cursor's position.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::io::Cursor;
     ///
     /// let mut buff = Cursor::new(Vec::new());
     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
     /// # force_inference(&buff);
     ///
     /// let reference = buff.get_mut();
     /// ```
     pub fn get_mut(&mut self) -> &mut T {
         &mut self.inner
     }

     /// Returns the current position of this cursor.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::io::Cursor;
     /// use std::io::prelude::*;
     /// use std::io::SeekFrom;
     ///
     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
     ///
     /// assert_eq!(buff.position(), 0);
     ///
     /// buff.seek(SeekFrom::Current(2)).unwrap();
     /// assert_eq!(buff.position(), 2);
     ///
     /// buff.seek(SeekFrom::Current(-1)).unwrap();
     /// assert_eq!(buff.position(), 1);
     /// ```
     pub const fn position(&self) -> u64 {
         self.pos
     }

     /// Sets the position of this cursor.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::io::Cursor;
     ///
     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
     ///
     /// assert_eq!(buff.position(), 0);
     ///
     /// buff.set_position(2);
     /// assert_eq!(buff.position(), 2);
     ///
     /// buff.set_position(4);
     /// assert_eq!(buff.position(), 4);
     /// ```
     pub fn set_position(&mut self, pos: u64) {
         self.pos = pos;
     }
 }

 impl<T> Cursor<T>
 where
     T: AsRef<[u8]>,
 {
     /// Returns the remaining slice.
     ///
     /// # Examples
     ///
     /// ```
     /// #![feature(cursor_remaining)]
     /// use std::io::Cursor;
     ///
     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
     ///
     /// assert_eq!(buff.remaining_slice(), &[1, 2, 3, 4, 5]);
     ///
     /// buff.set_position(2);
     /// assert_eq!(buff.remaining_slice(), &[3, 4, 5]);
     ///
     /// buff.set_position(4);
     /// assert_eq!(buff.remaining_slice(), &[5]);
     ///
     /// buff.set_position(6);
     /// assert_eq!(buff.remaining_slice(), &[]);
     /// ```
     pub fn remaining_slice(&self) -> &[u8] {
         let len = self.pos.min(self.inner.as_ref().len() as u64);
         &self.inner.as_ref()[(len as usize)..]
     }

     /// Returns `true` if the remaining slice is empty.
     ///
     /// # Examples
     ///
     /// ```
     /// #![feature(cursor_remaining)]
     /// use std::io::Cursor;
     ///
     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
     ///
     /// buff.set_position(2);
     /// assert!(!buff.is_empty());
     ///
     /// buff.set_position(5);
     /// assert!(buff.is_empty());
     ///
     /// buff.set_position(10);
     /// assert!(buff.is_empty());
     /// ```
     pub fn is_empty(&self) -> bool {
         self.pos >= self.inner.as_ref().len() as u64
     }
 }

 impl<T> Clone for Cursor<T>
 where
     T: Clone,
 {
     #[inline]
     fn clone(&self) -> Self {
         Cursor { inner: self.inner.clone(), pos: self.pos }
     }

     #[inline]
     fn clone_from(&mut self, other: &Self) {
         self.inner.clone_from(&other.inner);
         self.pos = other.pos;
     }
 }

 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::End(n) => (self.inner.as_ref().len() as u64, n),
             SeekFrom::Current(n) => (self.pos, n),
         };
         match base_pos.checked_add_signed(offset) {
             Some(n) => {
                 self.pos = n;
                 Ok(self.pos)
             }
             None => Err(io::const_io_error!(
                 ErrorKind::InvalidInput,
                 "invalid seek to a negative or overflowing position",
             )),
         }
     }

     fn stream_len(&mut self) -> io::Result<u64> {
         Ok(self.inner.as_ref().len() as u64)
     }

     fn stream_position(&mut self) -> io::Result<u64> {
         Ok(self.pos)
     }
 }

 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.remaining_slice(), buf)?;
         self.pos += n as u64;
         Ok(n)
     }

     fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
         let prev_filled = buf.filled_len();

         Read::read_buf(&mut self.fill_buf()?, buf)?;

         self.pos += (buf.filled_len() - prev_filled) as u64;

         Ok(())
     }

     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
         let mut nread = 0;
         for buf in bufs {
             let n = self.read(buf)?;
             nread += n;
             if n < buf.len() {
                 break;
             }
         }
         Ok(nread)
     }

     fn is_read_vectored(&self) -> bool {
         true
     }

     fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
         let n = buf.len();
         Read::read_exact(&mut self.remaining_slice(), buf)?;
         self.pos += n as u64;
         Ok(())
     }
 }

 impl<T> BufRead for Cursor<T>
 where
     T: AsRef<[u8]>,
 {
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
         Ok(self.remaining_slice())
     }
     fn consume(&mut self, amt: usize) {
         self.pos += amt as u64;
     }
 }

 // Non-resizing write implementation
 #[inline]
 fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
     let pos = cmp::min(*pos_mut, slice.len() as u64);
     let amt = (&mut slice[(pos as usize)..]).write(buf)?;
     *pos_mut += amt as u64;
     Ok(amt)
 }

 #[inline]
 fn slice_write_vectored(
     pos_mut: &mut u64,
     slice: &mut [u8],
     bufs: &[IoSlice<'_>],
 ) -> io::Result<usize> {
     let mut nwritten = 0;
     for buf in bufs {
         let n = slice_write(pos_mut, slice, buf)?;
         nwritten += n;
         if n < buf.len() {
             break;
         }
     }
     Ok(nwritten)
 }

 // 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(|_| {
         io::const_io_error!(
             ErrorKind::InvalidInput,
             "cursor position exceeds maximum possible vector length",
         )
     })?;
     // Make sure the internal buffer is as least as big as where we
     // currently are
     let len = vec.len();
     if len < pos {
         // use `resize` so that the zero filling is as efficient as possible
         vec.resize(pos, 0);
     }
     // Figure out what bytes will be used to overwrite what's currently
     // there (left), and what will be appended on the end (right)
     {
         let space = vec.len() - pos;
         let (left, right) = buf.split_at(cmp::min(space, buf.len()));
         vec[pos..pos + left.len()].copy_from_slice(left);
         vec.extend_from_slice(right);
     }

     // Bump us forward
     *pos_mut = (pos + buf.len()) as u64;
     Ok(buf.len())
 }

 fn vec_write_vectored(
     pos_mut: &mut u64,
     vec: &mut Vec<u8>,
     bufs: &[IoSlice<'_>],
 ) -> io::Result<usize> {
     let mut nwritten = 0;
     for buf in bufs {
         nwritten += vec_write(pos_mut, vec, buf)?;
     }
     Ok(nwritten)
 }

 impl Write for Cursor<&mut [u8]> {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         slice_write(&mut self.pos, self.inner, buf)
     }

     #[inline]
     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
         slice_write_vectored(&mut self.pos, self.inner, bufs)
     }

     #[inline]
     fn is_write_vectored(&self) -> bool {
         true
     }

     #[inline]
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
     }
 }

 impl Write for Cursor<&mut Vec<u8>> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         vec_write(&mut self.pos, self.inner, buf)
     }

     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
         vec_write_vectored(&mut self.pos, self.inner, bufs)
     }

     #[inline]
     fn is_write_vectored(&self) -> bool {
         true
     }

     #[inline]
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
     }
 }

 impl Write for Cursor<Vec<u8>> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         vec_write(&mut self.pos, &mut self.inner, buf)
     }

     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
         vec_write_vectored(&mut self.pos, &mut self.inner, bufs)
     }

     #[inline]
     fn is_write_vectored(&self) -> bool {
         true
     }

     #[inline]
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
     }
 }

 impl Write for Cursor<Box<[u8]>> {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         slice_write(&mut self.pos, &mut self.inner, buf)
     }

     #[inline]
     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
         slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
     }

     #[inline]
     fn is_write_vectored(&self) -> bool {
         true
     }

     #[inline]
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
     }
 }
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License..

	use crate::io::prelude::*;

	use crate::cmp;
	use crate::io::{self, ErrorKind, IoSlice, IoSliceMut, ReadBuf, SeekFrom};

	use core::convert::TryInto;

	/// A `Cursor` wraps an in-memory buffer and provides it with a
	/// [`Seek`] implementation.
	///
	/// `Cursor`s are used with in-memory buffers, anything implementing
	/// <code>[AsRef]<\[u8]></code>, to allow them to implement [`Read`] and/or [`Write`],
	/// allowing these buffers to be used anywhere you might use a reader or writer
	/// that does actual I/O.
	///
	/// The standard library implements some I/O traits on various types which
	/// are commonly used as a buffer, like <code>Cursor<[Vec]\<u8>></code> and
	/// <code>Cursor<[&\[u8\]][bytes]></code>.
	///
	/// # Examples
	///
	/// We may want to write bytes to a [`File`] in our production
	/// code, but use an in-memory buffer in our tests. We can do this with
	/// `Cursor`:
	///
	/// [bytes]: crate::slice "slice"
	/// [`File`]: crate::fs::File
	///
	/// ```no_run
	/// use std::io::prelude::*;
	/// use std::io::{self, SeekFrom};
	/// use std::fs::File;
	///
	/// // a library function we've written
	/// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
	/// writer.seek(SeekFrom::End(-10))?;
	///
	/// for i in 0..10 {
	/// writer.write(&[i])?;
	/// }
	///
	/// // all went well
	/// Ok(())
	/// }
	///
	/// # fn foo() -> io::Result<()> {
	/// // Here's some code that uses this library function.
	/// //
	/// // We might want to use a BufReader here for efficiency, but let's
	/// // keep this example focused.
	/// let mut file = File::create("foo.txt")?;
	///
	/// write_ten_bytes_at_end(&mut file)?;
	/// # Ok(())
	/// # }
	///
	/// // now let's write a test
	/// #[test]
	/// fn test_writes_bytes() {
	/// // setting up a real File is much slower than an in-memory buffer,
	/// // let's use a cursor instead
	/// use std::io::Cursor;
	/// let mut buff = Cursor::new(vec![0; 15]);
	///
	/// write_ten_bytes_at_end(&mut buff).unwrap();
	///
	/// assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
	/// }
	/// ```
	#[derive(Debug, Default, Eq, PartialEq)]
	pub struct Cursor<T> {
	inner: T,
	pos: u64,
	}

	impl<T> Cursor<T> {
	/// Creates a new cursor wrapping the provided underlying in-memory buffer.
	///
	/// Cursor initial position is `0` even if underlying buffer (e.g., [`Vec`])
	/// is not empty. So writing to cursor starts with overwriting [`Vec`]
	/// content, not with appending to it.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::Cursor;
	///
	/// let buff = Cursor::new(Vec::new());
	/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
	/// # force_inference(&buff);
	/// ```
	pub const fn new(inner: T) -> Cursor<T> {
	Cursor { pos: 0, inner }
	}

	/// Consumes this cursor, returning the underlying value.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::Cursor;
	///
	/// let buff = Cursor::new(Vec::new());
	/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
	/// # force_inference(&buff);
	///
	/// let vec = buff.into_inner();
	/// ```
	pub fn into_inner(self) -> T {
	self.inner
	}

	/// Gets a reference to the underlying value in this cursor.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::Cursor;
	///
	/// let buff = Cursor::new(Vec::new());
	/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
	/// # force_inference(&buff);
	///
	/// let reference = buff.get_ref();
	/// ```
	pub const fn get_ref(&self) -> &T {
	&self.inner
	}

	/// Gets a mutable reference to the underlying value in this cursor.
	///
	/// Care should be taken to avoid modifying the internal I/O state of the
	/// underlying value as it may corrupt this cursor's position.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::Cursor;
	///
	/// let mut buff = Cursor::new(Vec::new());
	/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
	/// # force_inference(&buff);
	///
	/// let reference = buff.get_mut();
	/// ```
	pub fn get_mut(&mut self) -> &mut T {
	&mut self.inner
	}

	/// Returns the current position of this cursor.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::Cursor;
	/// use std::io::prelude::*;
	/// use std::io::SeekFrom;
	///
	/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
	///
	/// assert_eq!(buff.position(), 0);
	///
	/// buff.seek(SeekFrom::Current(2)).unwrap();
	/// assert_eq!(buff.position(), 2);
	///
	/// buff.seek(SeekFrom::Current(-1)).unwrap();
	/// assert_eq!(buff.position(), 1);
	/// ```
	pub const fn position(&self) -> u64 {
	self.pos
	}

	/// Sets the position of this cursor.
	///
	/// # Examples
	///
	/// ```
	/// use std::io::Cursor;
	///
	/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
	///
	/// assert_eq!(buff.position(), 0);
	///
	/// buff.set_position(2);
	/// assert_eq!(buff.position(), 2);
	///
	/// buff.set_position(4);
	/// assert_eq!(buff.position(), 4);
	/// ```
	pub fn set_position(&mut self, pos: u64) {
	self.pos = pos;
	}
	}

	impl<T> Cursor<T>
	where
	T: AsRef<[u8]>,
	{
	/// Returns the remaining slice.
	///
	/// # Examples
	///
	/// ```
	/// #![feature(cursor_remaining)]
	/// use std::io::Cursor;
	///
	/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
	///
	/// assert_eq!(buff.remaining_slice(), &[1, 2, 3, 4, 5]);
	///
	/// buff.set_position(2);
	/// assert_eq!(buff.remaining_slice(), &[3, 4, 5]);
	///
	/// buff.set_position(4);
	/// assert_eq!(buff.remaining_slice(), &[5]);
	///
	/// buff.set_position(6);
	/// assert_eq!(buff.remaining_slice(), &[]);
	/// ```
	pub fn remaining_slice(&self) -> &[u8] {
	let len = self.pos.min(self.inner.as_ref().len() as u64);
	&self.inner.as_ref()[(len as usize)..]
	}

	/// Returns `true` if the remaining slice is empty.
	///
	/// # Examples
	///
	/// ```
	/// #![feature(cursor_remaining)]
	/// use std::io::Cursor;
	///
	/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
	///
	/// buff.set_position(2);
	/// assert!(!buff.is_empty());
	///
	/// buff.set_position(5);
	/// assert!(buff.is_empty());
	///
	/// buff.set_position(10);
	/// assert!(buff.is_empty());
	/// ```
	pub fn is_empty(&self) -> bool {
	self.pos >= self.inner.as_ref().len() as u64
	}
	}

	impl<T> Clone for Cursor<T>
	where
	T: Clone,
	{
	#[inline]
	fn clone(&self) -> Self {
	Cursor { inner: self.inner.clone(), pos: self.pos }
	}

	#[inline]
	fn clone_from(&mut self, other: &Self) {
	self.inner.clone_from(&other.inner);
	self.pos = other.pos;
	}
	}

	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::End(n) => (self.inner.as_ref().len() as u64, n),
	SeekFrom::Current(n) => (self.pos, n),
	};
	match base_pos.checked_add_signed(offset) {
	Some(n) => {
	self.pos = n;
	Ok(self.pos)
	}
	None => Err(io::const_io_error!(
	ErrorKind::InvalidInput,
	"invalid seek to a negative or overflowing position",
	)),
	}
	}

	fn stream_len(&mut self) -> io::Result<u64> {
	Ok(self.inner.as_ref().len() as u64)
	}

	fn stream_position(&mut self) -> io::Result<u64> {
	Ok(self.pos)
	}
	}

	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.remaining_slice(), buf)?;
	self.pos += n as u64;
	Ok(n)
	}

	fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
	let prev_filled = buf.filled_len();

	Read::read_buf(&mut self.fill_buf()?, buf)?;

	self.pos += (buf.filled_len() - prev_filled) as u64;

	Ok(())
	}

	fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
	let mut nread = 0;
	for buf in bufs {
	let n = self.read(buf)?;
	nread += n;
	if n < buf.len() {
	break;
	}
	}
	Ok(nread)
	}

	fn is_read_vectored(&self) -> bool {
	true
	}

	fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
	let n = buf.len();
	Read::read_exact(&mut self.remaining_slice(), buf)?;
	self.pos += n as u64;
	Ok(())
	}
	}

	impl<T> BufRead for Cursor<T>
	where
	T: AsRef<[u8]>,
	{
	fn fill_buf(&mut self) -> io::Result<&[u8]> {
	Ok(self.remaining_slice())
	}
	fn consume(&mut self, amt: usize) {
	self.pos += amt as u64;
	}
	}

	// Non-resizing write implementation
	#[inline]
	fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
	let pos = cmp::min(*pos_mut, slice.len() as u64);
	let amt = (&mut slice[(pos as usize)..]).write(buf)?;
	*pos_mut += amt as u64;
	Ok(amt)
	}

	#[inline]
	fn slice_write_vectored(
	pos_mut: &mut u64,
	slice: &mut [u8],
	bufs: &[IoSlice<'_>],
	) -> io::Result<usize> {
	let mut nwritten = 0;
	for buf in bufs {
	let n = slice_write(pos_mut, slice, buf)?;
	nwritten += n;
	if n < buf.len() {
	break;
	}
	}
	Ok(nwritten)
	}

	// 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(\|_\| {
	io::const_io_error!(
	ErrorKind::InvalidInput,
	"cursor position exceeds maximum possible vector length",
	)
	})?;
	// Make sure the internal buffer is as least as big as where we
	// currently are
	let len = vec.len();
	if len < pos {
	// use `resize` so that the zero filling is as efficient as possible
	vec.resize(pos, 0);
	}
	// Figure out what bytes will be used to overwrite what's currently
	// there (left), and what will be appended on the end (right)
	{
	let space = vec.len() - pos;
	let (left, right) = buf.split_at(cmp::min(space, buf.len()));
	vec[pos..pos + left.len()].copy_from_slice(left);
	vec.extend_from_slice(right);
	}

	// Bump us forward
	*pos_mut = (pos + buf.len()) as u64;
	Ok(buf.len())
	}

	fn vec_write_vectored(
	pos_mut: &mut u64,
	vec: &mut Vec<u8>,
	bufs: &[IoSlice<'_>],
	) -> io::Result<usize> {
	let mut nwritten = 0;
	for buf in bufs {
	nwritten += vec_write(pos_mut, vec, buf)?;
	}
	Ok(nwritten)
	}

	impl Write for Cursor<&mut [u8]> {
	#[inline]
	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
	slice_write(&mut self.pos, self.inner, buf)
	}

	#[inline]
	fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
	slice_write_vectored(&mut self.pos, self.inner, bufs)
	}

	#[inline]
	fn is_write_vectored(&self) -> bool {
	true
	}

	#[inline]
	fn flush(&mut self) -> io::Result<()> {
	Ok(())
	}
	}

	impl Write for Cursor<&mut Vec<u8>> {
	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
	vec_write(&mut self.pos, self.inner, buf)
	}

	fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
	vec_write_vectored(&mut self.pos, self.inner, bufs)
	}

	#[inline]
	fn is_write_vectored(&self) -> bool {
	true
	}

	#[inline]
	fn flush(&mut self) -> io::Result<()> {
	Ok(())
	}
	}

	impl Write for Cursor<Vec<u8>> {
	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
	vec_write(&mut self.pos, &mut self.inner, buf)
	}

	fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
	vec_write_vectored(&mut self.pos, &mut self.inner, bufs)
	}

	#[inline]
	fn is_write_vectored(&self) -> bool {
	true
	}

	#[inline]
	fn flush(&mut self) -> io::Result<()> {
	Ok(())
	}
	}

	impl Write for Cursor<Box<[u8]>> {
	#[inline]
	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
	slice_write(&mut self.pos, &mut self.inner, buf)
	}

	#[inline]
	fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
	slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
	}

	#[inline]
	fn is_write_vectored(&self) -> bool {
	true
	}

	#[inline]
	fn flush(&mut self) -> io::Result<()> {
	Ok(())
	}
	}