cheetah-string 2.1.0

A lightweight, high-performance string manipulation library optimized for speed-sensitive applications
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

use alloc::string::String;
use core::fmt;

use crate::{CheetahStr, CheetahString};

/// Append-heavy builder for constructing Cheetah string values.
///
/// `CheetahBuilder` keeps mutable construction separate from immutable
/// clone-cheap `CheetahStr` values and stable string values.
#[derive(Clone, Default)]
pub struct CheetahBuilder {
    inner: String,
}

impl CheetahBuilder {
    /// Creates an empty builder.
    #[inline]
    pub fn new() -> Self {
        Self {
            inner: String::new(),
        }
    }

    /// Creates an empty builder with at least `capacity` bytes.
    #[inline]
    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            inner: String::with_capacity(capacity),
        }
    }

    /// Creates a builder from existing owned storage.
    #[inline]
    pub fn from_string(value: String) -> Self {
        Self { inner: value }
    }

    /// Appends a string slice.
    #[inline]
    pub fn push_str(&mut self, value: &str) {
        self.inner.push_str(value);
    }

    /// Appends a character.
    #[inline]
    pub fn push(&mut self, value: char) {
        self.inner.push(value);
    }

    /// Reserves capacity for at least `additional` more bytes.
    #[inline]
    pub fn reserve(&mut self, additional: usize) {
        self.inner.reserve(additional);
    }

    /// Clears the current contents while preserving capacity.
    #[inline]
    pub fn clear(&mut self) {
        self.inner.clear();
    }

    /// Returns the current contents.
    #[inline]
    pub fn as_str(&self) -> &str {
        self.inner.as_str()
    }

    /// Returns the current length in bytes.
    #[inline]
    pub fn len(&self) -> usize {
        self.inner.len()
    }

    /// Returns whether the builder is empty.
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.inner.is_empty()
    }

    /// Returns the allocated capacity in bytes.
    #[inline]
    pub fn capacity(&self) -> usize {
        self.inner.capacity()
    }

    /// Finishes into a mutable string value, preserving spare capacity when it
    /// is useful for subsequent mutation.
    #[inline]
    pub fn finish_string(self) -> CheetahString {
        CheetahString::from_string_owned(self.inner)
    }

    /// Finishes into an immutable clone-cheap string value.
    #[inline]
    pub fn finish_str(self) -> CheetahStr {
        CheetahStr::from_string(self.inner)
    }

    /// Returns the owned `String` backing this builder.
    #[inline]
    pub fn into_string(self) -> String {
        self.inner
    }
}

impl From<String> for CheetahBuilder {
    #[inline]
    fn from(value: String) -> Self {
        Self::from_string(value)
    }
}

impl From<&str> for CheetahBuilder {
    #[inline]
    fn from(value: &str) -> Self {
        let mut builder = Self::with_capacity(value.len());
        builder.push_str(value);
        builder
    }
}

impl Extend<char> for CheetahBuilder {
    #[inline]
    fn extend<T: IntoIterator<Item = char>>(&mut self, iter: T) {
        self.inner.extend(iter);
    }
}

impl<'a> Extend<&'a str> for CheetahBuilder {
    #[inline]
    fn extend<T: IntoIterator<Item = &'a str>>(&mut self, iter: T) {
        for item in iter {
            self.push_str(item);
        }
    }
}

impl fmt::Debug for CheetahBuilder {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("CheetahBuilder")
            .field("value", &self.inner)
            .field("capacity", &self.inner.capacity())
            .finish()
    }
}