netcorehost 0.5.0

A Rust library for hosting .NET Core 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

use std::{
    borrow::{Borrow, BorrowMut},
    convert::TryFrom,
    fmt::{self, Debug, Display, Formatter},
    ops::{Deref, DerefMut},
    str::FromStr,
};

use super::{NulError, PdCStrInner, PdCStringInner, PdUChar};

/// A platform-dependent c-like string type for interacting with the hostfxr API.
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone)]
#[repr(transparent)]
pub struct PdCString(pub(crate) PdCStringInner);

impl PdCString {
    pub(crate) fn from_inner(inner: PdCStringInner) -> Self {
        Self(inner)
    }
    pub(crate) fn into_inner(self) -> PdCStringInner {
        self.0
    }
}

/// A borrowed slice of a PdCString.
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct PdCStr(pub(crate) PdCStrInner);

impl PdCStr {
    pub(crate) fn from_inner(inner: &PdCStrInner) -> &Self {
        // Safety:
        // Safe because PdCStr has the same layout as PdCStrInner
        unsafe { &*(inner as *const PdCStrInner as *const PdCStr) }
    }
    pub(crate) fn to_inner(&self) -> &PdCStrInner {
        // Safety:
        // Safe because PdCStr has the same layout as PdCStrInner
        unsafe { &*(self as *const PdCStr as *const PdCStrInner) }
    }
}

impl Borrow<PdCStr> for PdCString {
    fn borrow(&self) -> &PdCStr {
        PdCStr::from_inner(self.0.borrow())
    }
}

impl AsRef<PdCStr> for PdCString {
    fn as_ref(&self) -> &PdCStr {
        self.borrow()
    }
}

impl Deref for PdCString {
    type Target = PdCStr;

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

impl DerefMut for PdCString {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.borrow_mut()
    }
}

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

impl Display for PdCStr {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl From<PdCStringInner> for PdCString {
    fn from(s: PdCStringInner) -> Self {
        Self::from_inner(s)
    }
}

impl From<PdCString> for PdCStringInner {
    fn from(s: PdCString) -> Self {
        s.into_inner()
    }
}

impl<'a> From<&'a PdCStrInner> for &'a PdCStr {
    fn from(s: &'a PdCStrInner) -> Self {
        PdCStr::from_inner(s)
    }
}

impl<'a> From<&'a PdCStr> for &'a PdCStrInner {
    fn from(s: &'a PdCStr) -> Self {
        s.to_inner()
    }
}

impl<'a> TryFrom<&'a str> for PdCString {
    type Error = NulError;

    fn try_from(s: &'a str) -> Result<Self, Self::Error> {
        Self::from_str(s)
    }
}

impl TryFrom<Vec<PdUChar>> for PdCString {
    type Error = NulError;

    fn try_from(vec: Vec<PdUChar>) -> Result<Self, Self::Error> {
        Self::from_vec(vec)
    }
}

impl From<PdCString> for Vec<PdUChar> {
    fn from(s: PdCString) -> Vec<PdUChar> {
        s.into_vec()
    }
}

impl AsRef<PdCStr> for PdCStr {
    fn as_ref(&self) -> &Self {
        self
    }
}

impl ToOwned for PdCStr {
    type Owned = PdCString;
    fn to_owned(&self) -> Self::Owned {
        PdCString::from_inner(self.0.to_owned())
    }
}