cesu8str 0.2.4

Convert to and from CESU-8 or Modified UTF-8 encodings, only when necessary.
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

use std::borrow::Borrow;
use std::ops::Deref;


use crate::ngstr::prelude::*;

/// An owned CESU-8 encoded string.
/// 
/// See crate documentation for encoding details.
#[derive(PartialEq, Eq, Clone, Default)]
pub struct Cesu8String {
    pub(crate) inner: Vec<u8>,
}

impl Cesu8String {
    impl_string_encoding_meths!(base, "CESU-8");
    impl_string_encoding_meths!(string, "CESU-8");
}

impl Cesu8String {
    pub(crate) const unsafe fn _from_bytes_unchecked(b: Vec<u8>) -> Self {
        Cesu8String { inner: b }
    }

    pub(crate) const fn _into_bytes_unchecked(self) -> Vec<u8> {
        // taken from std::ffi::CString::into_inner

        // Rationale: `mem::forget(self)` invalidates the previous call to `ptr::read(&self.inner)`
        // so we use `ManuallyDrop` to ensure `self` is not dropped.
        // Then we can return the box directly without invalidating it.
        // See https://github.com/rust-lang/rust/issues/62553.
        let this = std::mem::ManuallyDrop::new(self);
        unsafe { std::ptr::read(&this.inner) }
    }
}

impl Borrow<Cesu8Str> for Cesu8String {
    fn borrow(&self) -> &Cesu8Str {
        self
    }
}
impl Deref for Cesu8String {
    type Target = Cesu8Str;
    fn deref(&self) -> &Self::Target {
        // SAFETY: this type should only contain valid mutf8
        unsafe { Self::Target::_from_bytes_unchecked(&self.inner) }
    }
}