hydroperx-utf16 1.0.0

Work with UTF-16 in Rust
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

use crate::{utils::*, Utf16Str, Utf16String};
use std::ops::{Deref, DerefMut};

impl Deref for Utf16String {
    type Target = Utf16Str;

    #[inline]
    fn deref(&self) -> &Self::Target {
        unsafe { Utf16Str::from_utf16_unchecked(self.buf.as_slice()) }
    }
}

impl DerefMut for Utf16String {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { Utf16Str::from_utf16_unchecked_mut(self.buf.as_mut_slice()) }
    }
}

impl<T: AsRef<str>> From<T> for Utf16String {
    fn from(value: T) -> Self {
        let mut r = Utf16String::new();
        r.push_utf8_str(value.as_ref());
        r
    }
}

impl From<Utf16String> for String {
    fn from(value: Utf16String) -> Self {
        value.to_utf8()
    }
}

impl Utf16String {
    pub fn new() -> Self {
        Utf16String {
            buf: vec![],
        }
    }

    #[inline]
    pub fn as_mut_utf16_str(&mut self) -> &mut Utf16Str {
        self
    }

    #[inline]
    pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u16> {
        &mut self.buf
    }

    #[inline]
    pub fn clear(&mut self) {
        self.buf.clear();
    }

    pub fn insert(&mut self, mut index: usize, ch: char) {
        for cu in encode_char(ch) {
            self.buf.insert(index, cu);
            index += 1;
        }
    }

    pub fn insert_utf16_str(&mut self, mut index: usize, string: &Utf16Str) {
        for cu in string.raw.iter() {
            self.buf.insert(index, *cu);
            index += 1;
        }
    }

    pub fn insert_utf8_str(&mut self, mut index: usize, string: &str) {
        for ch in string.chars() {
            for cu in encode_char(ch) {
                self.buf.insert(index, cu);
                index += 1;
            }
        }
    }

    #[inline]
    pub fn push(&mut self, ch: char) {
        self.buf.extend(encode_char(ch));
    }

    pub fn push_utf16_str(&mut self, string: &Utf16Str) {
        self.buf.extend(&string.raw);
    }

    pub fn push_utf8_str(&mut self, string: &str) {
        for ch in string.chars() {
            self.buf.extend(encode_char(ch));
        }
    }

    /// Removes a surrogate pair or a code unit from the specified
    /// index in code units, and returns the code point that was
    /// removed.
    /// 
    /// # Panics
    /// 
    /// Panics if the index is out of bounds.
    pub fn remove(&mut self, index: usize) -> char {
        assert!(index < self.len(), "removing character out of bounsd");
        let cu1 = self.buf[index];
        if is_high_surrogate(cu1) && (index + 1) < self.len() {
            let cu2 = self.buf[index + 1];
            if is_low_surrogate(cu2) {
                self.buf.remove(index);
                self.buf.remove(index);
                return decode_char(cu1, cu2);
            }
        }
        self.buf.remove(index);
        unsafe { char::from_u32_unchecked(cu1 as u32) }
    }

    /// Removes the last surrogate pair or code unit, and returns the code point that was
    /// removed.
    pub fn pop(&mut self) -> Option<char> {
        let l = self.len();
        if l == 0 {
            return None;
        }
        let i = l - 1;
        let cu2 = self.buf[i];
        if is_low_surrogate(cu2) && l > 1 {
            let cu1 = self.buf[i - 1];
            if is_high_surrogate(cu1) {
                let i2 = i - 1;
                self.buf.remove(i2);
                self.buf.remove(i2);
                return Some(decode_char(cu1, cu2));
            }
        }
        self.buf.remove(i);
        Some(unsafe { char::from_u32_unchecked(cu2 as u32) })
    }
}

impl Default for Utf16String {
    fn default() -> Self {
        Utf16String::new()
    }
}