130 lines
2.5 KiB
Rust
130 lines
2.5 KiB
Rust
use std::fmt;
|
|
use std::ops::{Add, AddAssign};
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Buffer {
|
|
inner: String,
|
|
}
|
|
|
|
impl Buffer {
|
|
#[inline]
|
|
pub const fn new() -> Buffer {
|
|
Self {
|
|
inner: String::new(),
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn with_capacity(n: usize) -> Buffer {
|
|
Self {
|
|
inner: String::with_capacity(n),
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn as_str(&self) -> &str {
|
|
&*self.inner
|
|
}
|
|
|
|
#[inline]
|
|
pub fn len(&self) -> usize {
|
|
self.inner.len()
|
|
}
|
|
|
|
#[inline]
|
|
pub fn capacity(&self) -> usize {
|
|
self.inner.capacity()
|
|
}
|
|
|
|
#[inline]
|
|
pub unsafe fn set_len(&mut self, new: usize) {
|
|
self.inner.as_mut_vec().set_len(new);
|
|
}
|
|
|
|
#[inline]
|
|
pub fn reserve(&mut self, n: usize) {
|
|
if n > self.inner.capacity() - self.inner.len() {
|
|
self.inner.reserve(n);
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn clear(&mut self) {
|
|
// unsafe { self.inner.set_len(0) };
|
|
self.inner.clear();
|
|
}
|
|
|
|
#[inline]
|
|
pub fn into_string(self) -> String {
|
|
self.inner
|
|
}
|
|
|
|
#[inline]
|
|
pub fn write_str(&mut self, data: &str) {
|
|
let inner_len = self.inner.len();
|
|
let size = data.len();
|
|
if size > self.inner.capacity() - self.inner.len() {
|
|
self.inner.reserve(size);
|
|
}
|
|
unsafe {
|
|
let p = self.inner.as_mut_ptr().add(self.inner.len());
|
|
std::ptr::copy_nonoverlapping(data.as_ptr(), p, size);
|
|
self.inner.as_mut_vec().set_len(inner_len + size);
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn write_char(&mut self, data: char) {
|
|
// TODO: do not use standard library
|
|
self.inner.push(data);
|
|
}
|
|
}
|
|
|
|
impl fmt::Write for Buffer {
|
|
#[inline]
|
|
fn write_str(&mut self, s: &str) -> fmt::Result {
|
|
Buffer::write_str(self, s);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl From<String> for Buffer {
|
|
#[inline]
|
|
fn from(other: String) -> Buffer {
|
|
Buffer { inner: other }
|
|
}
|
|
}
|
|
|
|
impl From<&str> for Buffer {
|
|
#[inline]
|
|
fn from(other: &str) -> Buffer {
|
|
Buffer {
|
|
inner: other.to_owned(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Add<&str> for Buffer {
|
|
type Output = Buffer;
|
|
|
|
#[inline]
|
|
fn add(mut self, other: &str) -> Buffer {
|
|
self.write_str(other);
|
|
self
|
|
}
|
|
}
|
|
|
|
impl AddAssign<&str> for Buffer {
|
|
#[inline]
|
|
fn add_assign(&mut self, other: &str) {
|
|
self.write_str(other)
|
|
}
|
|
}
|
|
|
|
impl Default for Buffer {
|
|
#[inline]
|
|
fn default() -> Buffer {
|
|
Buffer::new()
|
|
}
|
|
}
|