faststr 0.2.34

Faststr is a string library that reduces the cost of clone.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use core::{mem, ops::Deref, slice};

use alloc::{sync::Arc, vec::Vec};

use bytes::{Buf, Bytes};

// Vtable must enforce this behavior
unsafe impl Send for BytesRef {}
unsafe impl Sync for BytesRef {}

#[derive(Clone)]
pub struct BytesRef {
    pub(crate) ptr: *const u8,
    pub(crate) len: usize,
    pub(crate) data: Arc<Bytes>,
}

impl From<Bytes> for BytesRef {
    #[inline]
    fn from(data: Bytes) -> Self {
        BytesRef {
            ptr: data.as_ptr(),
            len: data.len(),
            data: Arc::new(data),
        }
    }
}

impl From<BytesRef> for Bytes {
    #[inline]
    fn from(value: BytesRef) -> Self {
        if value.len == 0 {
            return Bytes::new();
        }
        if value.ptr == value.data.as_ptr() && value.len == value.data.len() {
            return Arc::unwrap_or_clone(value.data);
        }

        let original_start = value.data.as_ptr();
        let offset = unsafe { value.ptr.offset_from(original_start) } as usize;
        value.data.slice(offset..offset + value.len)
    }
}

impl From<BytesRef> for Vec<u8> {
    #[inline]
    fn from(value: BytesRef) -> Self {
        Bytes::from(value).into()
    }
}

impl BytesRef {
    fn new_empty(&self) -> Self {
        Self {
            ptr: self.ptr,
            len: 0,
            data: self.data.clone(),
        }
    }

    /// Create a new borrowed “view” from this `BytesRef`, pointing to `subset`.
    ///
    /// This does not copy any bytes. It reuses the underlying `Arc<Bytes>` to keep
    /// the allocation alive.
    ///
    /// # Safety
    ///
    /// The caller must guarantee that:
    ///
    /// - `subset` is a true subslice of the bytes currently visible through `self`
    ///   (i.e. its address range is fully contained in `self`).
    pub unsafe fn slice_ref(&self, subset: &[u8]) -> Self {
        Self {
            ptr: subset.as_ptr(),
            len: subset.len(),
            data: self.data.clone(),
        }
    }

    #[inline]
    fn as_slice(&self) -> &[u8] {
        unsafe { slice::from_raw_parts(self.ptr, self.len) }
    }

    #[inline]
    /// # Safety
    ///
    /// - The caller must ensure `by <= self.len`.
    unsafe fn inc_start(&mut self, by: usize) {
        // should already be asserted, but debug assert for tests
        debug_assert!(self.len >= by, "internal: inc_start out of bounds");
        self.len -= by;
        self.ptr = self.ptr.add(by);
    }

    pub fn split_to(&mut self, at: usize) -> Self {
        if at == self.len() {
            return mem::replace(self, self.new_empty());
        }

        if at == 0 {
            return self.new_empty();
        }

        assert!(
            at <= self.len(),
            "split_to out of bounds: {:?} <= {:?}",
            at,
            self.len(),
        );

        let mut ret = self.clone();

        unsafe { self.inc_start(at) };

        ret.len = at;
        ret
    }
}

impl Deref for BytesRef {
    type Target = [u8];

    #[inline]
    fn deref(&self) -> &[u8] {
        self.as_slice()
    }
}

impl Buf for BytesRef {
    #[inline]
    fn remaining(&self) -> usize {
        self.len
    }

    #[inline]
    fn chunk(&self) -> &[u8] {
        self.as_slice()
    }

    #[inline]
    fn advance(&mut self, cnt: usize) {
        assert!(
            cnt <= self.len,
            "cannot advance past `remaining`: {:?} <= {:?}",
            cnt,
            self.len,
        );

        unsafe {
            self.inc_start(cnt);
        }
    }

    fn copy_to_bytes(&mut self, len: usize) -> Bytes {
        self.split_to(len).into()
    }
}