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
    PartialOrd,
28
    Serialize,
29
    Deserialize,
30
    Default
31
));
32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

98
    fn reflect_partial_cmp(&self, value: &dyn PartialReflect) -> Option<core::cmp::Ordering> {
99
        if let Some(value) = value.try_downcast_ref::<Self>() {
100
            PartialOrd::partial_cmp(self, value)
101
        } else {
102
            None
103
        }
104
    }
105

106
    fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
107
        if let Some(value) = value.try_downcast_ref::<Self>() {
108
            self.clone_from(value);
109
            Ok(())
110
        } else {
111
            Err(ApplyError::MismatchedTypes {
112
                from_type: value.reflect_type_path().into(),
113
                to_type: <Self as DynamicTypePath>::reflect_type_path(self).into(),
114
            })
115
        }
116
    }
117
}
118

119
impl Reflect for &'static Path {
120
    fn into_any(self: Box<Self>) -> Box<dyn Any> {
121
        self
122
    }
123

124
    fn as_any(&self) -> &dyn Any {
125
        self
126
    }
127

128
    fn as_any_mut(&mut self) -> &mut dyn Any {
129
        self
130
    }
131

132
    fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> {
133
        self
134
    }
135

136
    fn as_reflect(&self) -> &dyn Reflect {
137
        self
138
    }
139

140
    fn as_reflect_mut(&mut self) -> &mut dyn Reflect {
141
        self
142
    }
143

144
    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
145
        *self = value.take()?;
146
        Ok(())
147
    }
148
}
149

150
impl Typed for &'static Path {
151
    fn type_info() -> &'static TypeInfo {
152
        static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
153
        CELL.get_or_set(|| TypeInfo::Opaque(OpaqueInfo::new::<Self>()))
154
    }
155
}
156

157
impl GetTypeRegistration for &'static Path {
158
    fn get_type_registration() -> TypeRegistration {
159
        let mut registration = TypeRegistration::of::<Self>();
160
        registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
161
        registration.insert::<ReflectFromReflect>(FromType::<Self>::from_type());
162
        registration
163
    }
164
}
165

166
impl FromReflect for &'static Path {
167
    fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
168
        reflect.try_downcast_ref::<Self>().copied()
169
    }
170
}
171

172
impl PartialReflect for Cow<'static, Path> {
173
    fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
174
        Some(<Self as Typed>::type_info())
175
    }
176

177
    #[inline]
178
    fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect> {
179
        self
180
    }
181

182
    fn as_partial_reflect(&self) -> &dyn PartialReflect {
183
        self
184
    }
185

186
    fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect {
187
        self
188
    }
189

190
    fn try_into_reflect(self: Box<Self>) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>> {
191
        Ok(self)
192
    }
193

194
    fn try_as_reflect(&self) -> Option<&dyn Reflect> {
195
        Some(self)
196
    }
197

198
    fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect> {
199
        Some(self)
200
    }
201

202
    fn reflect_kind(&self) -> ReflectKind {
203
        ReflectKind::Opaque
204
    }
205

206
    fn reflect_ref(&self) -> ReflectRef<'_> {
207
        ReflectRef::Opaque(self)
208
    }
209

210
    fn reflect_mut(&mut self) -> ReflectMut<'_> {
211
        ReflectMut::Opaque(self)
212
    }
213

214
    fn reflect_owned(self: Box<Self>) -> ReflectOwned {
215
        ReflectOwned::Opaque(self)
216
    }
217

218
    fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError> {
219
        Ok(Box::new(self.clone()))
220
    }
221

222
    fn reflect_hash(&self) -> Option<u64> {
223
        let mut hasher = reflect_hasher();
224
        Hash::hash(&Any::type_id(self), &mut hasher);
225
        Hash::hash(self, &mut hasher);
226
        Some(hasher.finish())
227
    }
228

229
    fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
230
        if let Some(value) = value.try_downcast_ref::<Self>() {
231
            Some(PartialEq::eq(self, value))
232
        } else {
233
            Some(false)
234
        }
235
    }
236

237
    fn reflect_partial_cmp(&self, value: &dyn PartialReflect) -> Option<core::cmp::Ordering> {
238
        if let Some(value) = value.try_downcast_ref::<Self>() {
239
            PartialOrd::partial_cmp(self, value)
240
        } else {
241
            None
242
        }
243
    }
244

245
    fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
246
        fmt::Debug::fmt(&self, f)
247
    }
248

249
    fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
250
        if let Some(value) = value.try_downcast_ref::<Self>() {
251
            self.clone_from(value);
252
            Ok(())
253
        } else {
254
            Err(ApplyError::MismatchedTypes {
255
                from_type: value.reflect_type_path().into(),
256
                to_type: <Self as DynamicTypePath>::reflect_type_path(self).into(),
257
            })
258
        }
259
    }
260
}
261

262
impl Reflect for Cow<'static, Path> {
263
    fn into_any(self: Box<Self>) -> Box<dyn Any> {
264
        self
265
    }
266

267
    fn as_any(&self) -> &dyn Any {
268
        self
269
    }
270

271
    fn as_any_mut(&mut self) -> &mut dyn Any {
272
        self
273
    }
274

275
    fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> {
276
        self
277
    }
278

279
    fn as_reflect(&self) -> &dyn Reflect {
280
        self
281
    }
282

283
    fn as_reflect_mut(&mut self) -> &mut dyn Reflect {
284
        self
285
    }
286

287
    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
288
        *self = value.take()?;
289
        Ok(())
290
    }
291
}
292

293
impl Typed for Cow<'static, Path> {
294
    fn type_info() -> &'static TypeInfo {
295
        static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
296
        CELL.get_or_set(|| TypeInfo::Opaque(OpaqueInfo::new::<Self>()))
297
    }
298
}
299

300
impl_type_path!(::std::path::Path);
301

302
impl FromReflect for Cow<'static, Path> {
303
    fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
304
        Some(reflect.try_downcast_ref::<Self>()?.clone())
305
    }
306
}
307

308
impl GetTypeRegistration for Cow<'static, Path> {
309
    fn get_type_registration() -> TypeRegistration {
310
        let mut registration = TypeRegistration::of::<Self>();
311
        registration.insert::<ReflectDeserialize>(FromType::<Self>::from_type());
312
        registration.insert::<ReflectFromPtr>(FromType::<Self>::from_type());
313
        registration.insert::<ReflectSerialize>(FromType::<Self>::from_type());
314
        registration.insert::<ReflectFromReflect>(FromType::<Self>::from_type());
315
        registration
316
    }
317
}
318

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

322
Product

Resources

Company
