musli/alloc/
string.rs

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
use core::fmt;
use core::ops::Deref;
use core::str;

use crate::fixed::CapacityError;
use crate::Context;

use super::{Allocator, Vec};

/// Wrapper around a buffer that is guaranteed to be a valid utf-8 string.
pub struct String<'a, A>
where
    A: 'a + ?Sized + Allocator,
{
    buf: Vec<'a, u8, A>,
}

/// Collect a string into a string buffer.
pub(crate) fn collect_string<C, T>(cx: &C, value: T) -> Result<String<'_, C::Allocator>, C::Error>
where
    C: ?Sized + Context,
    T: fmt::Display,
{
    use core::fmt::Write;

    let mut string = String::new_in(cx.alloc());

    if write!(string, "{value}").is_err() {
        return Err(cx.message("Failed to write to string"));
    }

    Ok(string)
}

impl<'a, A> String<'a, A>
where
    A: 'a + ?Sized + Allocator,
{
    /// Construct a new string buffer in the provided allocator.
    pub fn new_in(alloc: &'a A) -> Self {
        Self::new(alloc.new_raw_vec::<u8>())
    }

    /// Construct a new fixed string.
    pub(crate) const fn new(buf: A::RawVec<'a, u8>) -> Self {
        Self { buf: Vec::new(buf) }
    }

    fn as_str(&self) -> &str {
        // SAFETY: Interactions ensure that data is valid utf-8.
        unsafe { str::from_utf8_unchecked(self.buf.as_slice()) }
    }

    fn try_push(&mut self, c: char) -> Result<(), CapacityError> {
        if !self.buf.write(c.encode_utf8(&mut [0; 4]).as_bytes()) {
            return Err(CapacityError);
        }

        Ok(())
    }

    fn try_push_str(&mut self, s: &str) -> Result<(), CapacityError> {
        if !self.buf.write(s.as_bytes()) {
            return Err(CapacityError);
        }

        Ok(())
    }
}

impl<'a, A> fmt::Write for String<'a, A>
where
    A: 'a + ?Sized + Allocator,
{
    #[inline]
    fn write_char(&mut self, c: char) -> fmt::Result {
        self.try_push(c).map_err(|_| fmt::Error)
    }

    #[inline]
    fn write_str(&mut self, s: &str) -> fmt::Result {
        self.try_push_str(s).map_err(|_| fmt::Error)
    }
}

impl<'a, A> Deref for String<'a, A>
where
    A: 'a + ?Sized + Allocator,
{
    type Target = str;

    #[inline]
    fn deref(&self) -> &str {
        unsafe { str::from_utf8_unchecked(self.buf.as_slice()) }
    }
}

impl<'a, A> fmt::Display for String<'a, A>
where
    A: 'a + ?Sized + Allocator,
{
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_str().fmt(f)
    }
}

impl<'a, A> fmt::Debug for String<'a, A>
where
    A: 'a + ?Sized + Allocator,
{
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_str().fmt(f)
    }
}

impl<'a, A> AsRef<str> for String<'a, A>
where
    A: ?Sized + Allocator,
{
    #[inline]
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}