implement BufMut for Buffer
This commit is contained in:
cel 🌸
parent
8d9566dbb8
commit
0a9c9ab1e2
|
|
@ -17,3 +17,4 @@ include = [
|
|||
]
|
||||
|
||||
[dependencies]
|
||||
bytes = "1.8.0"
|
||||
|
|
|
|||
674
src/lib.rs
674
src/lib.rs
|
|
@ -47,369 +47,421 @@
|
|||
//! assert_eq!(b.data(), &b"cd"[..]);
|
||||
//! }
|
||||
//!
|
||||
use std::{cmp, ptr};
|
||||
use std::io::{self,Write,Read};
|
||||
use std::io::{self, Read, Write};
|
||||
use std::iter::repeat;
|
||||
use std::{cmp, ptr};
|
||||
|
||||
extern crate bytes;
|
||||
use bytes::BufMut;
|
||||
|
||||
/// the Buffer contains the underlying memory and data positions
|
||||
///
|
||||
/// In all cases, `0 ≤ position ≤ end ≤ capacity` should be true
|
||||
#[derive(Debug,PartialEq,Clone)]
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub struct Buffer {
|
||||
/// the Vec containing the data
|
||||
memory: Vec<u8>,
|
||||
/// the current capacity of the Buffer
|
||||
capacity: usize,
|
||||
/// the current beginning of the available data
|
||||
position: usize,
|
||||
/// the current end of the available data
|
||||
/// and beginning of the available space
|
||||
end: usize
|
||||
/// the Vec containing the data
|
||||
memory: Vec<u8>,
|
||||
/// the current capacity of the Buffer
|
||||
capacity: usize,
|
||||
/// the current beginning of the available data
|
||||
position: usize,
|
||||
/// the current end of the available data
|
||||
/// and beginning of the available space
|
||||
end: usize,
|
||||
}
|
||||
|
||||
impl Buffer {
|
||||
/// allocates a new buffer of maximum size `capacity`
|
||||
pub fn with_capacity(capacity: usize) -> Buffer {
|
||||
let mut v = Vec::with_capacity(capacity);
|
||||
v.extend(repeat(0).take(capacity));
|
||||
Buffer {
|
||||
memory: v,
|
||||
capacity: capacity,
|
||||
position: 0,
|
||||
end: 0
|
||||
}
|
||||
}
|
||||
|
||||
/// allocates a new buffer containing the slice `data`
|
||||
///
|
||||
/// the buffer starts full, its available data size is exactly `data.len()`
|
||||
pub fn from_slice(data: &[u8]) -> Buffer {
|
||||
Buffer {
|
||||
memory: Vec::from(data),
|
||||
capacity: data.len(),
|
||||
position: 0,
|
||||
end: data.len()
|
||||
}
|
||||
}
|
||||
|
||||
/// increases the size of the buffer
|
||||
///
|
||||
/// this does nothing if the buffer is already large enough
|
||||
pub fn grow(&mut self, new_size: usize) -> bool {
|
||||
if self.capacity >= new_size {
|
||||
return false;
|
||||
/// allocates a new buffer of maximum size `capacity`
|
||||
pub fn with_capacity(capacity: usize) -> Buffer {
|
||||
let mut v = Vec::with_capacity(capacity);
|
||||
v.extend(repeat(0).take(capacity));
|
||||
Buffer {
|
||||
memory: v,
|
||||
capacity: capacity,
|
||||
position: 0,
|
||||
end: 0,
|
||||
}
|
||||
}
|
||||
|
||||
self.memory.resize(new_size, 0);
|
||||
self.capacity = new_size;
|
||||
true
|
||||
}
|
||||
|
||||
/// returns how much data can be read from the buffer
|
||||
pub fn available_data(&self) -> usize {
|
||||
self.end - self.position
|
||||
}
|
||||
|
||||
/// returns how much free space is available to write to
|
||||
pub fn available_space(&self) -> usize {
|
||||
self.capacity - self.end
|
||||
}
|
||||
|
||||
/// returns the underlying vector's size
|
||||
pub fn capacity(&self) -> usize {
|
||||
self.capacity
|
||||
}
|
||||
|
||||
/// returns true if there is no more data to read
|
||||
pub fn empty(&self) -> bool {
|
||||
self.position == self.end
|
||||
}
|
||||
|
||||
/// advances the position tracker
|
||||
///
|
||||
/// if the position gets past the buffer's half,
|
||||
/// this will call `shift()` to move the remaining data
|
||||
/// to the beginning of the buffer
|
||||
pub fn consume(&mut self, count: usize) -> usize {
|
||||
let cnt = cmp::min(count, self.available_data());
|
||||
self.position += cnt;
|
||||
if self.position > self.capacity / 2 {
|
||||
//trace!("consume shift: pos {}, end {}", self.position, self.end);
|
||||
self.shift();
|
||||
}
|
||||
cnt
|
||||
}
|
||||
|
||||
/// advances the position tracker
|
||||
///
|
||||
/// This method is similar to `consume()` but will not move data
|
||||
/// to the beginning of the buffer
|
||||
pub fn consume_noshift(&mut self, count: usize) -> usize {
|
||||
let cnt = cmp::min(count, self.available_data());
|
||||
self.position += cnt;
|
||||
cnt
|
||||
}
|
||||
|
||||
/// after having written data to the buffer, use this function
|
||||
/// to indicate how many bytes were written
|
||||
///
|
||||
/// if there is not enough available space, this function can call
|
||||
/// `shift()` to move the remaining data to the beginning of the
|
||||
/// buffer
|
||||
pub fn fill(&mut self, count: usize) -> usize {
|
||||
let cnt = cmp::min(count, self.available_space());
|
||||
self.end += cnt;
|
||||
if self.available_space() < self.available_data() + cnt {
|
||||
//trace!("fill shift: pos {}, end {}", self.position, self.end);
|
||||
self.shift();
|
||||
/// allocates a new buffer containing the slice `data`
|
||||
///
|
||||
/// the buffer starts full, its available data size is exactly `data.len()`
|
||||
pub fn from_slice(data: &[u8]) -> Buffer {
|
||||
Buffer {
|
||||
memory: Vec::from(data),
|
||||
capacity: data.len(),
|
||||
position: 0,
|
||||
end: data.len(),
|
||||
}
|
||||
}
|
||||
|
||||
cnt
|
||||
}
|
||||
/// increases the size of the buffer
|
||||
///
|
||||
/// this does nothing if the buffer is already large enough
|
||||
pub fn grow(&mut self, new_size: usize) -> bool {
|
||||
if self.capacity >= new_size {
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Get the current position
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// use circular::Buffer;
|
||||
/// use std::io::{Read,Write};
|
||||
///
|
||||
/// let mut output = [0;5];
|
||||
///
|
||||
/// let mut b = Buffer::with_capacity(10);
|
||||
///
|
||||
/// let res = b.write(&b"abcdefgh"[..]);
|
||||
///
|
||||
/// b.read(&mut output);
|
||||
///
|
||||
/// // Position must be 5
|
||||
/// assert_eq!(b.position(), 5);
|
||||
/// assert_eq!(b.available_data(), 3);
|
||||
/// ```
|
||||
pub fn position(&self) -> usize {
|
||||
self.position
|
||||
}
|
||||
self.memory.resize(new_size, 0);
|
||||
self.capacity = new_size;
|
||||
true
|
||||
}
|
||||
|
||||
/// moves the position and end trackers to the beginning
|
||||
/// this function does not modify the data
|
||||
pub fn reset(&mut self) {
|
||||
self.position = 0;
|
||||
self.end = 0;
|
||||
}
|
||||
/// returns how much data can be read from the buffer
|
||||
pub fn available_data(&self) -> usize {
|
||||
self.end - self.position
|
||||
}
|
||||
|
||||
/// returns a slice with all the available data
|
||||
pub fn data(&self) -> &[u8] {
|
||||
&self.memory[self.position..self.end]
|
||||
}
|
||||
/// returns how much free space is available to write to
|
||||
pub fn available_space(&self) -> usize {
|
||||
self.capacity - self.end
|
||||
}
|
||||
|
||||
/// returns a mutable slice with all the available space to
|
||||
/// write to
|
||||
pub fn space(&mut self) -> &mut[u8] {
|
||||
&mut self.memory[self.end..self.capacity]
|
||||
}
|
||||
/// returns the underlying vector's size
|
||||
pub fn capacity(&self) -> usize {
|
||||
self.capacity
|
||||
}
|
||||
|
||||
/// moves the data at the beginning of the buffer
|
||||
///
|
||||
/// if the position was more than 0, it is now 0
|
||||
pub fn shift(&mut self) {
|
||||
if self.position > 0 {
|
||||
unsafe {
|
||||
let length = self.end - self.position;
|
||||
ptr::copy( (&self.memory[self.position..self.end]).as_ptr(), (&mut self.memory[..length]).as_mut_ptr(), length);
|
||||
/// returns true if there is no more data to read
|
||||
pub fn empty(&self) -> bool {
|
||||
self.position == self.end
|
||||
}
|
||||
|
||||
/// advances the position tracker
|
||||
///
|
||||
/// if the position gets past the buffer's half,
|
||||
/// this will call `shift()` to move the remaining data
|
||||
/// to the beginning of the buffer
|
||||
pub fn consume(&mut self, count: usize) -> usize {
|
||||
let cnt = cmp::min(count, self.available_data());
|
||||
self.position += cnt;
|
||||
if self.position > self.capacity / 2 {
|
||||
//trace!("consume shift: pos {}, end {}", self.position, self.end);
|
||||
self.shift();
|
||||
}
|
||||
cnt
|
||||
}
|
||||
|
||||
/// advances the position tracker
|
||||
///
|
||||
/// This method is similar to `consume()` but will not move data
|
||||
/// to the beginning of the buffer
|
||||
pub fn consume_noshift(&mut self, count: usize) -> usize {
|
||||
let cnt = cmp::min(count, self.available_data());
|
||||
self.position += cnt;
|
||||
cnt
|
||||
}
|
||||
|
||||
/// after having written data to the buffer, use this function
|
||||
/// to indicate how many bytes were written
|
||||
///
|
||||
/// if there is not enough available space, this function can call
|
||||
/// `shift()` to move the remaining data to the beginning of the
|
||||
/// buffer
|
||||
pub fn fill(&mut self, count: usize) -> usize {
|
||||
let cnt = cmp::min(count, self.available_space());
|
||||
self.end += cnt;
|
||||
if self.available_space() < self.available_data() + cnt {
|
||||
//trace!("fill shift: pos {}, end {}", self.position, self.end);
|
||||
self.shift();
|
||||
}
|
||||
|
||||
cnt
|
||||
}
|
||||
|
||||
/// Get the current position
|
||||
///
|
||||
/// # Examples
|
||||
/// ```
|
||||
/// use circular::Buffer;
|
||||
/// use std::io::{Read,Write};
|
||||
///
|
||||
/// let mut output = [0;5];
|
||||
///
|
||||
/// let mut b = Buffer::with_capacity(10);
|
||||
///
|
||||
/// let res = b.write(&b"abcdefgh"[..]);
|
||||
///
|
||||
/// b.read(&mut output);
|
||||
///
|
||||
/// // Position must be 5
|
||||
/// assert_eq!(b.position(), 5);
|
||||
/// assert_eq!(b.available_data(), 3);
|
||||
/// ```
|
||||
pub fn position(&self) -> usize {
|
||||
self.position
|
||||
}
|
||||
|
||||
/// moves the position and end trackers to the beginning
|
||||
/// this function does not modify the data
|
||||
pub fn reset(&mut self) {
|
||||
self.position = 0;
|
||||
self.end = length;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//FIXME: this should probably be rewritten, and tested extensively
|
||||
#[doc(hidden)]
|
||||
pub fn delete_slice(&mut self, start: usize, length: usize) -> Option<usize> {
|
||||
if start + length >= self.available_data() {
|
||||
return None
|
||||
self.end = 0;
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let begin = self.position + start;
|
||||
let next_end = self.end - length;
|
||||
ptr::copy(
|
||||
(&self.memory[begin+length..self.end]).as_ptr(),
|
||||
(&mut self.memory[begin..next_end]).as_mut_ptr(),
|
||||
self.end - (begin+length)
|
||||
);
|
||||
self.end = next_end;
|
||||
}
|
||||
Some(self.available_data())
|
||||
}
|
||||
|
||||
//FIXME: this should probably be rewritten, and tested extensively
|
||||
#[doc(hidden)]
|
||||
pub fn replace_slice(&mut self, data: &[u8], start: usize, length: usize) -> Option<usize> {
|
||||
let data_len = data.len();
|
||||
if start + length > self.available_data() ||
|
||||
self.position + start + data_len > self.capacity {
|
||||
return None
|
||||
/// returns a slice with all the available data
|
||||
pub fn data(&self) -> &[u8] {
|
||||
&self.memory[self.position..self.end]
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let begin = self.position + start;
|
||||
let slice_end = begin + data_len;
|
||||
// we reduced the data size
|
||||
if data_len < length {
|
||||
ptr::copy(data.as_ptr(), (&mut self.memory[begin..slice_end]).as_mut_ptr(), data_len);
|
||||
|
||||
ptr::copy((&self.memory[start+length..self.end]).as_ptr(), (&mut self.memory[slice_end..]).as_mut_ptr(), self.end - (start + length));
|
||||
self.end = self.end - (length - data_len);
|
||||
|
||||
// we put more data in the buffer
|
||||
} else {
|
||||
ptr::copy((&self.memory[start+length..self.end]).as_ptr(), (&mut self.memory[start+data_len..]).as_mut_ptr(), self.end - (start + length));
|
||||
ptr::copy(data.as_ptr(), (&mut self.memory[begin..slice_end]).as_mut_ptr(), data_len);
|
||||
self.end = self.end + data_len - length;
|
||||
}
|
||||
}
|
||||
Some(self.available_data())
|
||||
}
|
||||
|
||||
//FIXME: this should probably be rewritten, and tested extensively
|
||||
#[doc(hidden)]
|
||||
pub fn insert_slice(&mut self, data: &[u8], start: usize) -> Option<usize> {
|
||||
let data_len = data.len();
|
||||
if start > self.available_data() ||
|
||||
self.position + self.end + data_len > self.capacity {
|
||||
return None
|
||||
/// returns a mutable slice with all the available space to
|
||||
/// write to
|
||||
pub fn space(&mut self) -> &mut [u8] {
|
||||
&mut self.memory[self.end..self.capacity]
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let begin = self.position + start;
|
||||
let slice_end = begin + data_len;
|
||||
ptr::copy((&self.memory[start..self.end]).as_ptr(), (&mut self.memory[start+data_len..]).as_mut_ptr(), self.end - start);
|
||||
ptr::copy(data.as_ptr(), (&mut self.memory[begin..slice_end]).as_mut_ptr(), data_len);
|
||||
self.end = self.end + data_len;
|
||||
/// moves the data at the beginning of the buffer
|
||||
///
|
||||
/// if the position was more than 0, it is now 0
|
||||
pub fn shift(&mut self) {
|
||||
if self.position > 0 {
|
||||
unsafe {
|
||||
let length = self.end - self.position;
|
||||
ptr::copy(
|
||||
(&self.memory[self.position..self.end]).as_ptr(),
|
||||
(&mut self.memory[..length]).as_mut_ptr(),
|
||||
length,
|
||||
);
|
||||
self.position = 0;
|
||||
self.end = length;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//FIXME: this should probably be rewritten, and tested extensively
|
||||
#[doc(hidden)]
|
||||
pub fn delete_slice(&mut self, start: usize, length: usize) -> Option<usize> {
|
||||
if start + length >= self.available_data() {
|
||||
return None;
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let begin = self.position + start;
|
||||
let next_end = self.end - length;
|
||||
ptr::copy(
|
||||
(&self.memory[begin + length..self.end]).as_ptr(),
|
||||
(&mut self.memory[begin..next_end]).as_mut_ptr(),
|
||||
self.end - (begin + length),
|
||||
);
|
||||
self.end = next_end;
|
||||
}
|
||||
Some(self.available_data())
|
||||
}
|
||||
|
||||
//FIXME: this should probably be rewritten, and tested extensively
|
||||
#[doc(hidden)]
|
||||
pub fn replace_slice(&mut self, data: &[u8], start: usize, length: usize) -> Option<usize> {
|
||||
let data_len = data.len();
|
||||
if start + length > self.available_data()
|
||||
|| self.position + start + data_len > self.capacity
|
||||
{
|
||||
return None;
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let begin = self.position + start;
|
||||
let slice_end = begin + data_len;
|
||||
// we reduced the data size
|
||||
if data_len < length {
|
||||
ptr::copy(
|
||||
data.as_ptr(),
|
||||
(&mut self.memory[begin..slice_end]).as_mut_ptr(),
|
||||
data_len,
|
||||
);
|
||||
|
||||
ptr::copy(
|
||||
(&self.memory[start + length..self.end]).as_ptr(),
|
||||
(&mut self.memory[slice_end..]).as_mut_ptr(),
|
||||
self.end - (start + length),
|
||||
);
|
||||
self.end = self.end - (length - data_len);
|
||||
|
||||
// we put more data in the buffer
|
||||
} else {
|
||||
ptr::copy(
|
||||
(&self.memory[start + length..self.end]).as_ptr(),
|
||||
(&mut self.memory[start + data_len..]).as_mut_ptr(),
|
||||
self.end - (start + length),
|
||||
);
|
||||
ptr::copy(
|
||||
data.as_ptr(),
|
||||
(&mut self.memory[begin..slice_end]).as_mut_ptr(),
|
||||
data_len,
|
||||
);
|
||||
self.end = self.end + data_len - length;
|
||||
}
|
||||
}
|
||||
Some(self.available_data())
|
||||
}
|
||||
|
||||
//FIXME: this should probably be rewritten, and tested extensively
|
||||
#[doc(hidden)]
|
||||
pub fn insert_slice(&mut self, data: &[u8], start: usize) -> Option<usize> {
|
||||
let data_len = data.len();
|
||||
if start > self.available_data() || self.position + self.end + data_len > self.capacity {
|
||||
return None;
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let begin = self.position + start;
|
||||
let slice_end = begin + data_len;
|
||||
ptr::copy(
|
||||
(&self.memory[start..self.end]).as_ptr(),
|
||||
(&mut self.memory[start + data_len..]).as_mut_ptr(),
|
||||
self.end - start,
|
||||
);
|
||||
ptr::copy(
|
||||
data.as_ptr(),
|
||||
(&mut self.memory[begin..slice_end]).as_mut_ptr(),
|
||||
data_len,
|
||||
);
|
||||
self.end = self.end + data_len;
|
||||
}
|
||||
Some(self.available_data())
|
||||
}
|
||||
Some(self.available_data())
|
||||
}
|
||||
}
|
||||
|
||||
impl Write for Buffer {
|
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||
match self.space().write(buf) {
|
||||
Ok(size) => { self.fill(size); Ok(size) },
|
||||
err => err
|
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||
match self.space().write(buf) {
|
||||
Ok(size) => {
|
||||
self.fill(size);
|
||||
Ok(size)
|
||||
}
|
||||
err => err,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Read for Buffer {
|
||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||
let len = cmp::min(self.available_data(), buf.len());
|
||||
unsafe {
|
||||
ptr::copy((&self.memory[self.position..self.position+len]).as_ptr(), buf.as_mut_ptr(), len);
|
||||
self.position += len;
|
||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||
let len = cmp::min(self.available_data(), buf.len());
|
||||
unsafe {
|
||||
ptr::copy(
|
||||
(&self.memory[self.position..self.position + len]).as_ptr(),
|
||||
buf.as_mut_ptr(),
|
||||
len,
|
||||
);
|
||||
self.position += len;
|
||||
}
|
||||
Ok(len)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl BufMut for Buffer {
|
||||
fn remaining_mut(&self) -> usize {
|
||||
self.available_space()
|
||||
}
|
||||
|
||||
unsafe fn advance_mut(&mut self, cnt: usize) {
|
||||
self.fill(cnt);
|
||||
}
|
||||
|
||||
fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
|
||||
self.space().into()
|
||||
}
|
||||
Ok(len)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::io::Write;
|
||||
use super::*;
|
||||
use std::io::Write;
|
||||
|
||||
#[test]
|
||||
fn fill_and_consume() {
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
assert_eq!(b.available_data(), 0);
|
||||
assert_eq!(b.available_space(), 10);
|
||||
let res = b.write(&b"abcd"[..]);
|
||||
assert_eq!(res.ok(), Some(4));
|
||||
assert_eq!(b.available_data(), 4);
|
||||
assert_eq!(b.available_space(), 6);
|
||||
#[test]
|
||||
fn fill_and_consume() {
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
assert_eq!(b.available_data(), 0);
|
||||
assert_eq!(b.available_space(), 10);
|
||||
let res = b.write(&b"abcd"[..]);
|
||||
assert_eq!(res.ok(), Some(4));
|
||||
assert_eq!(b.available_data(), 4);
|
||||
assert_eq!(b.available_space(), 6);
|
||||
|
||||
assert_eq!(b.data(), &b"abcd"[..]);
|
||||
assert_eq!(b.data(), &b"abcd"[..]);
|
||||
|
||||
b.consume(2);
|
||||
assert_eq!(b.available_data(), 2);
|
||||
assert_eq!(b.available_space(), 6);
|
||||
assert_eq!(b.data(), &b"cd"[..]);
|
||||
b.consume(2);
|
||||
assert_eq!(b.available_data(), 2);
|
||||
assert_eq!(b.available_space(), 6);
|
||||
assert_eq!(b.data(), &b"cd"[..]);
|
||||
|
||||
b.shift();
|
||||
assert_eq!(b.available_data(), 2);
|
||||
assert_eq!(b.available_space(), 8);
|
||||
assert_eq!(b.data(), &b"cd"[..]);
|
||||
b.shift();
|
||||
assert_eq!(b.available_data(), 2);
|
||||
assert_eq!(b.available_space(), 8);
|
||||
assert_eq!(b.data(), &b"cd"[..]);
|
||||
|
||||
assert_eq!(b.write(&b"efghijklmnop"[..]).ok(), Some(8));
|
||||
assert_eq!(b.available_data(), 10);
|
||||
assert_eq!(b.available_space(), 0);
|
||||
assert_eq!(b.data(), &b"cdefghijkl"[..]);
|
||||
b.shift();
|
||||
assert_eq!(b.available_data(), 10);
|
||||
assert_eq!(b.available_space(), 0);
|
||||
assert_eq!(b.data(), &b"cdefghijkl"[..]);
|
||||
}
|
||||
assert_eq!(b.write(&b"efghijklmnop"[..]).ok(), Some(8));
|
||||
assert_eq!(b.available_data(), 10);
|
||||
assert_eq!(b.available_space(), 0);
|
||||
assert_eq!(b.data(), &b"cdefghijkl"[..]);
|
||||
b.shift();
|
||||
assert_eq!(b.available_data(), 10);
|
||||
assert_eq!(b.available_space(), 0);
|
||||
assert_eq!(b.data(), &b"cdefghijkl"[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete() {
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
let _ = b.write(&b"abcdefgh"[..]);
|
||||
assert_eq!(b.available_data(), 8);
|
||||
assert_eq!(b.available_space(), 2);
|
||||
#[test]
|
||||
fn delete() {
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
let _ = b.write(&b"abcdefgh"[..]);
|
||||
assert_eq!(b.available_data(), 8);
|
||||
assert_eq!(b.available_space(), 2);
|
||||
|
||||
assert_eq!(b.delete_slice(2, 3), Some(5));
|
||||
assert_eq!(b.available_data(), 5);
|
||||
assert_eq!(b.available_space(), 5);
|
||||
assert_eq!(b.data(), &b"abfgh"[..]);
|
||||
assert_eq!(b.delete_slice(2, 3), Some(5));
|
||||
assert_eq!(b.available_data(), 5);
|
||||
assert_eq!(b.available_space(), 5);
|
||||
assert_eq!(b.data(), &b"abfgh"[..]);
|
||||
|
||||
assert_eq!(b.delete_slice(5, 2), None);
|
||||
assert_eq!(b.delete_slice(4, 2), None);
|
||||
}
|
||||
assert_eq!(b.delete_slice(5, 2), None);
|
||||
assert_eq!(b.delete_slice(4, 2), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replace() {
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
let _ = b.write(&b"abcdefgh"[..]);
|
||||
assert_eq!(b.available_data(), 8);
|
||||
assert_eq!(b.available_space(), 2);
|
||||
#[test]
|
||||
fn replace() {
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
let _ = b.write(&b"abcdefgh"[..]);
|
||||
assert_eq!(b.available_data(), 8);
|
||||
assert_eq!(b.available_space(), 2);
|
||||
|
||||
assert_eq!(b.replace_slice(&b"ABC"[..], 2, 3), Some(8));
|
||||
assert_eq!(b.available_data(), 8);
|
||||
assert_eq!(b.available_space(), 2);
|
||||
assert_eq!(b.data(), &b"abABCfgh"[..]);
|
||||
assert_eq!(b.replace_slice(&b"ABC"[..], 2, 3), Some(8));
|
||||
assert_eq!(b.available_data(), 8);
|
||||
assert_eq!(b.available_space(), 2);
|
||||
assert_eq!(b.data(), &b"abABCfgh"[..]);
|
||||
|
||||
assert_eq!(b.replace_slice(&b"XYZ"[..], 8, 3), None);
|
||||
assert_eq!(b.replace_slice(&b"XYZ"[..], 6, 3), None);
|
||||
assert_eq!(b.replace_slice(&b"XYZ"[..], 8, 3), None);
|
||||
assert_eq!(b.replace_slice(&b"XYZ"[..], 6, 3), None);
|
||||
|
||||
assert_eq!(b.replace_slice(&b"XYZ"[..], 2, 4), Some(7));
|
||||
assert_eq!(b.available_data(), 7);
|
||||
assert_eq!(b.available_space(), 3);
|
||||
assert_eq!(b.data(), &b"abXYZgh"[..]);
|
||||
assert_eq!(b.replace_slice(&b"XYZ"[..], 2, 4), Some(7));
|
||||
assert_eq!(b.available_data(), 7);
|
||||
assert_eq!(b.available_space(), 3);
|
||||
assert_eq!(b.data(), &b"abXYZgh"[..]);
|
||||
|
||||
assert_eq!(b.replace_slice(&b"123"[..], 2, 2), Some(8));
|
||||
assert_eq!(b.available_data(), 8);
|
||||
assert_eq!(b.available_space(), 2);
|
||||
assert_eq!(b.data(), &b"ab123Zgh"[..]);
|
||||
}
|
||||
assert_eq!(b.replace_slice(&b"123"[..], 2, 2), Some(8));
|
||||
assert_eq!(b.available_data(), 8);
|
||||
assert_eq!(b.available_space(), 2);
|
||||
assert_eq!(b.data(), &b"ab123Zgh"[..]);
|
||||
}
|
||||
|
||||
use std::str;
|
||||
#[test]
|
||||
fn set_position() {
|
||||
let mut output = [0;5];
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
let _ = b.write(&b"abcdefgh"[..]);
|
||||
let _ = b.read(&mut output);
|
||||
assert_eq!(b.available_data(), 3);
|
||||
println!("{:?}", b.position());
|
||||
}
|
||||
use std::str;
|
||||
#[test]
|
||||
fn set_position() {
|
||||
let mut output = [0; 5];
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
let _ = b.write(&b"abcdefgh"[..]);
|
||||
let _ = b.read(&mut output);
|
||||
assert_eq!(b.available_data(), 3);
|
||||
println!("{:?}", b.position());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn consume_without_shift() {
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
let _ = b.write(&b"abcdefgh"[..]);
|
||||
b.consume_noshift(6);
|
||||
assert_eq!(b.position(), 6);
|
||||
}
|
||||
#[test]
|
||||
fn consume_without_shift() {
|
||||
let mut b = Buffer::with_capacity(10);
|
||||
let _ = b.write(&b"abcdefgh"[..]);
|
||||
b.consume_noshift(6);
|
||||
assert_eq!(b.position(), 6);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue