deno.land / x / deno@v1.28.2 / core / io.rs
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
use std::ops::Deref;use std::ops::DerefMut;
use serde_v8::ZeroCopyBuf;
/// BufView is a wrapper around an underlying contiguous chunk of bytes. It can/// be created from a [ZeroCopyBuf], [bytes::Bytes], or [Vec<u8>] and implements/// `Deref<[u8]>` and `AsRef<[u8]>`.////// The wrapper has the ability to constrain the exposed view to a sub-region of/// the underlying buffer. This is useful for write operations, because they may/// have to be called multiple times, with different views onto the buffer to be/// able to write it entirely.pub struct BufView { inner: BufViewInner, cursor: usize,}
enum BufViewInner { Empty, Bytes(bytes::Bytes), ZeroCopy(ZeroCopyBuf), Vec(Vec<u8>),}
impl BufView { fn from_inner(inner: BufViewInner) -> Self { Self { inner, cursor: 0 } }
pub fn empty() -> Self { Self::from_inner(BufViewInner::Empty) }
/// Get the length of the buffer view. This is the length of the underlying /// buffer minus the cursor position. pub fn len(&self) -> usize { match &self.inner { BufViewInner::Empty => 0, BufViewInner::Bytes(bytes) => bytes.len() - self.cursor, BufViewInner::ZeroCopy(zero_copy) => zero_copy.len() - self.cursor, BufViewInner::Vec(vec) => vec.len() - self.cursor, } }
/// Is the buffer view empty? pub fn is_empty(&self) -> bool { self.len() == 0 }
/// Advance the internal cursor of the buffer view by `n` bytes. pub fn advance_cursor(&mut self, n: usize) { assert!(self.len() >= n); self.cursor += n; }
/// Reset the internal cursor of the buffer view to the beginning of the /// buffer. Returns the old cursor position. pub fn reset_cursor(&mut self) -> usize { let old = self.cursor; self.cursor = 0; old }}
impl Deref for BufView { type Target = [u8];
fn deref(&self) -> &[u8] { let buf = match &self.inner { BufViewInner::Empty => &[], BufViewInner::Bytes(bytes) => bytes.deref(), BufViewInner::ZeroCopy(zero_copy) => zero_copy.deref(), BufViewInner::Vec(vec) => vec.deref(), }; &buf[self.cursor..] }}
impl AsRef<[u8]> for BufView { fn as_ref(&self) -> &[u8] { self.deref() }}
impl From<ZeroCopyBuf> for BufView { fn from(buf: ZeroCopyBuf) -> Self { Self::from_inner(BufViewInner::ZeroCopy(buf)) }}
impl From<Vec<u8>> for BufView { fn from(vec: Vec<u8>) -> Self { Self::from_inner(BufViewInner::Vec(vec)) }}
impl From<bytes::Bytes> for BufView { fn from(buf: bytes::Bytes) -> Self { Self::from_inner(BufViewInner::Bytes(buf)) }}
impl From<BufView> for bytes::Bytes { fn from(buf: BufView) -> Self { match buf.inner { BufViewInner::Empty => bytes::Bytes::new(), BufViewInner::Bytes(bytes) => bytes, BufViewInner::ZeroCopy(zero_copy) => zero_copy.into(), BufViewInner::Vec(vec) => vec.into(), } }}
/// BufMutView is a wrapper around an underlying contiguous chunk of writable/// bytes. It can be created from a `ZeroCopyBuf` or a `Vec<u8>` and implements/// `DerefMut<[u8]>` and `AsMut<[u8]>`.////// The wrapper has the ability to constrain the exposed view to a sub-region of/// the underlying buffer. This is useful for write operations, because they may/// have to be called multiple times, with different views onto the buffer to be/// able to write it entirely.////// A `BufMutView` can be turned into a `BufView` by calling `BufMutView::into_view`.pub struct BufMutView { inner: BufMutViewInner, cursor: usize,}
enum BufMutViewInner { ZeroCopy(ZeroCopyBuf), Vec(Vec<u8>),}
impl BufMutView { fn from_inner(inner: BufMutViewInner) -> Self { Self { inner, cursor: 0 } }
pub fn new(len: usize) -> Self { Self::from_inner(BufMutViewInner::Vec(vec![0; len])) }
/// Get the length of the buffer view. This is the length of the underlying /// buffer minus the cursor position. pub fn len(&self) -> usize { match &self.inner { BufMutViewInner::ZeroCopy(zero_copy) => zero_copy.len() - self.cursor, BufMutViewInner::Vec(vec) => vec.len() - self.cursor, } }
/// Is the buffer view empty? pub fn is_empty(&self) -> bool { self.len() == 0 }
/// Advance the internal cursor of the buffer view by `n` bytes. pub fn advance_cursor(&mut self, n: usize) { assert!(self.len() >= n); self.cursor += n; }
/// Reset the internal cursor of the buffer view to the beginning of the /// buffer. Returns the old cursor position. pub fn reset_cursor(&mut self) -> usize { let old = self.cursor; self.cursor = 0; old }
/// Turn this `BufMutView` into a `BufView`. pub fn into_view(self) -> BufView { let inner = match self.inner { BufMutViewInner::ZeroCopy(zero_copy) => BufViewInner::ZeroCopy(zero_copy), BufMutViewInner::Vec(vec) => BufViewInner::Vec(vec), }; BufView { inner, cursor: self.cursor, } }
/// Unwrap the underlying buffer into a `Vec<u8>`, consuming the `BufMutView`. /// /// This method panics when called on a `BufMutView` that was created from a /// `ZeroCopyBuf`. pub fn unwrap_vec(self) -> Vec<u8> { match self.inner { BufMutViewInner::ZeroCopy(_) => { panic!("Cannot unwrap a ZeroCopyBuf backed BufMutView into a Vec"); } BufMutViewInner::Vec(vec) => vec, } }
/// Get a mutable reference to an underlying `Vec<u8>`. /// /// This method panics when called on a `BufMutView` that was created from a /// `ZeroCopyBuf`. pub fn get_mut_vec(&mut self) -> &mut Vec<u8> { match &mut self.inner { BufMutViewInner::ZeroCopy(_) => { panic!("Cannot unwrap a ZeroCopyBuf backed BufMutView into a Vec"); } BufMutViewInner::Vec(vec) => vec, } }}
impl Deref for BufMutView { type Target = [u8];
fn deref(&self) -> &[u8] { let buf = match &self.inner { BufMutViewInner::ZeroCopy(zero_copy) => zero_copy.deref(), BufMutViewInner::Vec(vec) => vec.deref(), }; &buf[self.cursor..] }}
impl DerefMut for BufMutView { fn deref_mut(&mut self) -> &mut [u8] { let buf = match &mut self.inner { BufMutViewInner::ZeroCopy(zero_copy) => zero_copy.deref_mut(), BufMutViewInner::Vec(vec) => vec.deref_mut(), }; &mut buf[self.cursor..] }}
impl AsRef<[u8]> for BufMutView { fn as_ref(&self) -> &[u8] { self.deref() }}
impl AsMut<[u8]> for BufMutView { fn as_mut(&mut self) -> &mut [u8] { self.deref_mut() }}
impl From<ZeroCopyBuf> for BufMutView { fn from(buf: ZeroCopyBuf) -> Self { Self::from_inner(BufMutViewInner::ZeroCopy(buf)) }}
impl From<Vec<u8>> for BufMutView { fn from(buf: Vec<u8>) -> Self { Self::from_inner(BufMutViewInner::Vec(buf)) }}
pub enum WriteOutcome { Partial { nwritten: usize, view: BufView }, Full { nwritten: usize },}
impl WriteOutcome { pub fn nwritten(&self) -> usize { match self { WriteOutcome::Partial { nwritten, .. } => *nwritten, WriteOutcome::Full { nwritten } => *nwritten, } }}
Version Info