eso 0.0.2

Type machinery to build Cow-like containers
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

// Copyright (c) 2021 Sebastien Braun
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#![allow(dead_code)]

use eso::{
    borrow::{Borrow, Take},
    An, Eso, No,
};
use std::ops::{Deref, DerefMut};

pub struct OwnedString(Eso<No<&'static str>, No<&'static str>, An<String>>);

pub struct StaticString(Eso<No<&'static str>, An<&'static str>, An<String>>);

pub struct StringRef<'a>(Eso<An<&'a str>, An<&'static str>, No<String>>);

impl OwnedString {
    pub fn new(s: String) -> Self {
        Self(Eso::from_owned(s))
    }
}

impl StaticString {
    pub fn new_string(s: String) -> Self {
        Self(Eso::from_owned(s))
    }

    pub const fn new_static(s: &'static str) -> Self {
        Self(Eso::from_static(s))
    }
}

impl<'a> Borrow<'a, StringRef<'a>> for OwnedString {
    fn borrow(&'a self) -> StringRef<'a> {
        StringRef(self.0.reference())
    }
}

impl<'a> Borrow<'a, StringRef<'a>> for StaticString {
    fn borrow(&'a self) -> StringRef<'a> {
        StringRef(self.0.reference())
    }
}

impl<'a> Take<OwnedString> for StringRef<'a> {
    fn to_owned(&self) -> OwnedString {
        OwnedString(self.0.to_owning().relax())
    }
}

impl<'a> Deref for StringRef<'a> {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        self.0.get_ref()
    }
}

impl Deref for StaticString {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        self.0.get_ref()
    }
}

impl Deref for OwnedString {
    type Target = String;

    fn deref(&self) -> &Self::Target {
        self.0.get_owned_ref()
    }
}

impl DerefMut for OwnedString {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.0.get_mut()
    }
}