CoCalc -- path.rs

GitHub Repository: bevyengine/bevy
Path: blob/main/crates/bevy_reflect/src/impls/std/path.rs
⁶⁶⁰⁰ views
1
use crate::{
2
    error::ReflectCloneError,
3
    kind::{ReflectKind, ReflectMut, ReflectOwned, ReflectRef},
4
    prelude::*,
5
    reflect::ApplyError,
6
    type_info::{OpaqueInfo, TypeInfo, Typed},
7
    type_path::DynamicTypePath,
8
    type_registry::{
9
        FromType, GetTypeRegistration, ReflectDeserialize, ReflectFromPtr, ReflectSerialize,
10
        TypeRegistration,
11
    },
12
    utility::{reflect_hasher, NonGenericTypeInfoCell},
13
};
14
use alloc::borrow::Cow;
15
use bevy_platform::prelude::*;
16
use bevy_reflect_derive::{impl_reflect_opaque, impl_type_path};
17
use core::any::Any;
18
use core::fmt;
19
use core::hash::{Hash, Hasher};
20
use std::path::Path;
21

22
impl_reflect_opaque!(::std::path::PathBuf(
23
    Clone,
24
    Debug,
25
    Hash,
26
    PartialEq,
27
    Serialize,
28
    Deserialize,
29
    Default
30
));
31

32
impl PartialReflect for &'static Path {
33
    fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
34
        Some(<Self as Typed>::type_info())
35
    }
36

37
    #[inline]
38
    fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect> {
39
        self
40
    }
41

42
    fn as_partial_reflect(&self) -> &dyn PartialReflect {
43
        self
44
    }
45

46
    fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect {
47
        self
48
    }
49

50
    fn try_into_reflect(self: Box<Self>) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>> {
51
        Ok(self)
52
    }
53

54
    fn try_as_reflect(&self) -> Option<&dyn Reflect> {
55
        Some(self)
56
    }
57

58
    fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect> {
59
        Some(self)
60
    }
61

62
    fn reflect_kind(&self) -> ReflectKind {
63
        ReflectKind::Opaque
64
    }
65

66
    fn reflect_ref(&self) -> ReflectRef<'_> {
67
        ReflectRef::Opaque(self)
68
    }
69

70
    fn reflect_mut(&mut self) -> ReflectMut<'_> {
71
        ReflectMut::Opaque(self)
72
    }
73

74
    fn reflect_owned(self: Box<Self>) -> ReflectOwned {
75
        ReflectOwned::Opaque(self)
76
    }
77

78
    fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError> {
79
        Ok(Box::new(*self))
80
    }
81

82
    fn reflect_hash(&self) -> Option<u64> {
83
        let mut hasher = reflect_hasher();
84
        Hash::hash(&Any::type_id(self), &mut hasher);
85
        Hash::hash(self, &mut hasher);
86
        Some(hasher.finish())
87
    }
88

89
    fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
90
        if let Some(value) = value.try_downcast_ref::<Self>() {
91
            Some(PartialEq::eq(self, value))
92
        } else {
93
            Some(false)
94
        }
95
    }
96

97
    fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
98
        if let Some(value) = value.try_downcast_ref::<Self>() {
99
            self.clone_from(value);
100
            Ok(())
101
        } else {
102
            Err(ApplyError::MismatchedTypes {
103
                from_type: value.reflect_type_path().into(),
104
                to_type: <Self as DynamicTypePath>::reflect_type_path(self).into(),
105
            })
106
        }
107
    }
108
}
109

110
impl Reflect for &'static Path {
111
    fn into_any(self: Box<Self>) -> Box<dyn Any> {
112
        self
113
    }
114

115
    fn as_any(&self) -> &dyn Any {
116
        self
117
    }
118

119
    fn as_any_mut(&mut self) -> &mut dyn Any {
120
        self
121
    }
122

123
    fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> {
124
        self
125
    }
126

127
    fn as_reflect(&self) -> &dyn Reflect {
128
        self
129
    }
130

131
    fn as_reflect_mut(&mut self) -> &mut dyn Reflect {
132
        self
133
    }
134

135
    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
136
        *self = value.take()?;
137
        Ok(())
138
    }
139
}
140

141
impl Typed for &'static Path {
142
    fn type_info() -> &'static TypeInfo {
143
        static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
144
        CELL.get_or_set(|| TypeInfo::Opaque(OpaqueInfo::new::<Self>()))
145
    }
146
}
147

148
impl GetTypeRegistration for &'static Path {
149
    fn get_type_registration() -> TypeRegistration {
150
        let mut registration = TypeRegistration::of::<Self>();
151
        registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
152
        registration.insert::<ReflectFromReflect>(FromType::<Self>::from_type());
153
        registration
154
    }
155
}
156

157
impl FromReflect for &'static Path {
158
    fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
159
        reflect.try_downcast_ref::<Self>().copied()
160
    }
161
}
162

163
impl PartialReflect for Cow<'static, Path> {
164
    fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
165
        Some(<Self as Typed>::type_info())
166
    }
167

168
    #[inline]
169
    fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect> {
170
        self
171
    }
172

173
    fn as_partial_reflect(&self) -> &dyn PartialReflect {
174
        self
175
    }
176

177
    fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect {
178
        self
179
    }
180

181
    fn try_into_reflect(self: Box<Self>) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>> {
182
        Ok(self)
183
    }
184

185
    fn try_as_reflect(&self) -> Option<&dyn Reflect> {
186
        Some(self)
187
    }
188

189
    fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect> {
190
        Some(self)
191
    }
192

193
    fn reflect_kind(&self) -> ReflectKind {
194
        ReflectKind::Opaque
195
    }
196

197
    fn reflect_ref(&self) -> ReflectRef<'_> {
198
        ReflectRef::Opaque(self)
199
    }
200

201
    fn reflect_mut(&mut self) -> ReflectMut<'_> {
202
        ReflectMut::Opaque(self)
203
    }
204

205
    fn reflect_owned(self: Box<Self>) -> ReflectOwned {
206
        ReflectOwned::Opaque(self)
207
    }
208

209
    fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError> {
210
        Ok(Box::new(self.clone()))
211
    }
212

213
    fn reflect_hash(&self) -> Option<u64> {
214
        let mut hasher = reflect_hasher();
215
        Hash::hash(&Any::type_id(self), &mut hasher);
216
        Hash::hash(self, &mut hasher);
217
        Some(hasher.finish())
218
    }
219

220
    fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
221
        if let Some(value) = value.try_downcast_ref::<Self>() {
222
            Some(PartialEq::eq(self, value))
223
        } else {
224
            Some(false)
225
        }
226
    }
227

228
    fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
229
        fmt::Debug::fmt(&self, f)
230
    }
231

232
    fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
233
        if let Some(value) = value.try_downcast_ref::<Self>() {
234
            self.clone_from(value);
235
            Ok(())
236
        } else {
237
            Err(ApplyError::MismatchedTypes {
238
                from_type: value.reflect_type_path().into(),
239
                to_type: <Self as DynamicTypePath>::reflect_type_path(self).into(),
240
            })
241
        }
242
    }
243
}
244

245
impl Reflect for Cow<'static, Path> {
246
    fn into_any(self: Box<Self>) -> Box<dyn Any> {
247
        self
248
    }
249

250
    fn as_any(&self) -> &dyn Any {
251
        self
252
    }
253

254
    fn as_any_mut(&mut self) -> &mut dyn Any {
255
        self
256
    }
257

258
    fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> {
259
        self
260
    }
261

262
    fn as_reflect(&self) -> &dyn Reflect {
263
        self
264
    }
265

266
    fn as_reflect_mut(&mut self) -> &mut dyn Reflect {
267
        self
268
    }
269

270
    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
271
        *self = value.take()?;
272
        Ok(())
273
    }
274
}
275

276
impl Typed for Cow<'static, Path> {
277
    fn type_info() -> &'static TypeInfo {
278
        static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
279
        CELL.get_or_set(|| TypeInfo::Opaque(OpaqueInfo::new::<Self>()))
280
    }
281
}
282

283
impl_type_path!(::std::path::Path);
284

285
impl FromReflect for Cow<'static, Path> {
286
    fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
287
        Some(reflect.try_downcast_ref::<Self>()?.clone())
288
    }
289
}
290

291
impl GetTypeRegistration for Cow<'static, Path> {
292
    fn get_type_registration() -> TypeRegistration {
293
        let mut registration = TypeRegistration::of::<Self>();
294
        registration.insert::<ReflectDeserialize>(FromType::<Self>::from_type());
295
        registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
296
        registration.insert::<ReflectSerialize>(FromType::<Self>::from_type());
297
        registration.insert::<ReflectFromReflect>(FromType::<Self>::from_type());
298
        registration
299
    }
300
}
301

302
#[cfg(feature = "functions")]
303
crate::func::macros::impl_function_traits!(Cow<'static, Path>);
304

305
Product

Resources

Company
