1use super::class_requires::*;
2use super::*;
3#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkMemoryResourceHandleExternalLink<'a> {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "serde", serde(borrow))]
31 #[cfg_attr(feature = "json_schema", schemars(rename = "memberName"))]
32 #[cfg_attr(feature = "serde", serde(rename = "memberName"))]
33 pub m_memberName: StringPtr<'a>,
34 #[cfg_attr(feature = "serde", serde(borrow))]
39 #[cfg_attr(feature = "json_schema", schemars(rename = "externalId"))]
40 #[cfg_attr(feature = "serde", serde(rename = "externalId"))]
41 pub m_externalId: StringPtr<'a>,
42}
43const _: () = {
44 use havok_serde as _serde;
45 impl<'a> _serde::HavokClass for hkMemoryResourceHandleExternalLink<'a> {
46 #[inline]
47 fn name(&self) -> &'static str {
48 "hkMemoryResourceHandleExternalLink"
49 }
50 #[inline]
51 fn signature(&self) -> _serde::__private::Signature {
52 _serde::__private::Signature::new(0x3144d17c)
53 }
54 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
55 fn deps_indexes(&self) -> Vec<usize> {
56 let mut v = Vec::new();
57 v
58 }
59 }
60 impl<'a> _serde::Serialize for hkMemoryResourceHandleExternalLink<'a> {
61 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
62 where
63 S: _serde::ser::Serializer,
64 {
65 let class_meta = self
66 .__ptr
67 .map(|name| (name, _serde::__private::Signature::new(0x3144d17c)));
68 let mut serializer = __serializer
69 .serialize_struct(
70 "hkMemoryResourceHandleExternalLink",
71 class_meta,
72 (8u64, 16u64),
73 )?;
74 serializer.serialize_field("memberName", &self.m_memberName)?;
75 serializer.serialize_field("externalId", &self.m_externalId)?;
76 serializer.end()
77 }
78 }
79};
80#[doc(hidden)]
81#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
82const _: () = {
83 use havok_serde as _serde;
84 #[automatically_derived]
85 impl<'de> _serde::Deserialize<'de> for hkMemoryResourceHandleExternalLink<'de> {
86 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
87 where
88 __D: _serde::Deserializer<'de>,
89 {
90 #[allow(non_camel_case_types)]
91 enum __Field {
92 m_memberName,
93 m_externalId,
94 __ignore,
95 }
96 struct __FieldVisitor;
97 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
98 type Value = __Field;
99 fn expecting(
100 &self,
101 __formatter: &mut core::fmt::Formatter,
102 ) -> core::fmt::Result {
103 core::fmt::Formatter::write_str(__formatter, "field identifier")
104 }
105 #[allow(clippy::match_single_binding)]
107 #[allow(clippy::reversed_empty_ranges)]
108 #[allow(clippy::single_match)]
109 fn visit_key<__E>(
110 self,
111 __value: &str,
112 ) -> core::result::Result<Self::Value, __E>
113 where
114 __E: _serde::de::Error,
115 {
116 match __value {
117 "memberName" => Ok(__Field::m_memberName),
118 "externalId" => Ok(__Field::m_externalId),
119 _ => Ok(__Field::__ignore),
120 }
121 }
122 }
123 impl<'de> _serde::Deserialize<'de> for __Field {
124 #[inline]
125 fn deserialize<__D>(
126 __deserializer: __D,
127 ) -> core::result::Result<Self, __D::Error>
128 where
129 __D: _serde::Deserializer<'de>,
130 {
131 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
132 }
133 }
134 struct __hkMemoryResourceHandleExternalLinkVisitor<'de> {
135 marker: _serde::__private::PhantomData<
136 hkMemoryResourceHandleExternalLink<'de>,
137 >,
138 lifetime: _serde::__private::PhantomData<&'de ()>,
139 }
140 #[allow(clippy::match_single_binding)]
141 #[allow(clippy::reversed_empty_ranges)]
142 #[allow(clippy::single_match)]
143 impl<'de> _serde::de::Visitor<'de>
144 for __hkMemoryResourceHandleExternalLinkVisitor<'de> {
145 type Value = hkMemoryResourceHandleExternalLink<'de>;
146 fn expecting(
147 &self,
148 __formatter: &mut core::fmt::Formatter,
149 ) -> core::fmt::Result {
150 core::fmt::Formatter::write_str(
151 __formatter,
152 "struct hkMemoryResourceHandleExternalLink",
153 )
154 }
155 fn visit_struct_for_bytes<__A>(
156 self,
157 mut __map: __A,
158 ) -> _serde::__private::Result<Self::Value, __A::Error>
159 where
160 __A: _serde::de::MapAccess<'de>,
161 {
162 let __ptr = __A::class_ptr(&mut __map);
163 let mut m_memberName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
164 let mut m_externalId: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
165 for i in 0..2usize {
166 match i {
167 0usize => {
168 if _serde::__private::Option::is_some(&m_memberName) {
169 return _serde::__private::Err(
170 <__A::Error as _serde::de::Error>::duplicate_field(
171 "memberName",
172 ),
173 );
174 }
175 m_memberName = _serde::__private::Some(
176 match __A::next_value::<StringPtr<'de>>(&mut __map) {
177 _serde::__private::Ok(__val) => __val,
178 _serde::__private::Err(__err) => {
179 return _serde::__private::Err(__err);
180 }
181 },
182 );
183 }
184 1usize => {
185 if _serde::__private::Option::is_some(&m_externalId) {
186 return _serde::__private::Err(
187 <__A::Error as _serde::de::Error>::duplicate_field(
188 "externalId",
189 ),
190 );
191 }
192 m_externalId = _serde::__private::Some(
193 match __A::next_value::<StringPtr<'de>>(&mut __map) {
194 _serde::__private::Ok(__val) => __val,
195 _serde::__private::Err(__err) => {
196 return _serde::__private::Err(__err);
197 }
198 },
199 );
200 }
201 _ => {}
202 }
203 }
204 let m_memberName = match m_memberName {
205 _serde::__private::Some(__field) => __field,
206 _serde::__private::None => {
207 return _serde::__private::Err(
208 <__A::Error as _serde::de::Error>::missing_field(
209 "memberName",
210 ),
211 );
212 }
213 };
214 let m_externalId = match m_externalId {
215 _serde::__private::Some(__field) => __field,
216 _serde::__private::None => {
217 return _serde::__private::Err(
218 <__A::Error as _serde::de::Error>::missing_field(
219 "externalId",
220 ),
221 );
222 }
223 };
224 _serde::__private::Ok(hkMemoryResourceHandleExternalLink {
225 __ptr,
226 m_memberName,
227 m_externalId,
228 })
229 }
230 #[allow(clippy::manual_unwrap_or_default)]
231 fn visit_struct<__A>(
232 self,
233 mut __map: __A,
234 ) -> _serde::__private::Result<Self::Value, __A::Error>
235 where
236 __A: _serde::de::MapAccess<'de>,
237 {
238 let mut m_memberName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
239 let mut m_externalId: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
240 while let _serde::__private::Some(__key) = {
241 __A::next_key::<__Field>(&mut __map)?
242 } {
243 match __key {
244 __Field::m_memberName => {
245 #[cfg(
246 any(feature = "strict", feature = "ignore_duplicates")
247 )]
248 if _serde::__private::Option::is_some(&m_memberName) {
249 #[cfg(feature = "ignore_duplicates")]
250 {
251 __A::skip_value(&mut __map)?;
252 continue;
253 }
254 #[cfg(feature = "strict")]
255 return _serde::__private::Err(
256 <__A::Error as _serde::de::Error>::duplicate_field(
257 "memberName",
258 ),
259 );
260 }
261 m_memberName = _serde::__private::Some(
262 match __A::next_value::<StringPtr<'de>>(&mut __map) {
263 _serde::__private::Ok(__val) => __val,
264 _serde::__private::Err(__err) => {
265 return _serde::__private::Err(__err);
266 }
267 },
268 );
269 }
270 __Field::m_externalId => {
271 #[cfg(
272 any(feature = "strict", feature = "ignore_duplicates")
273 )]
274 if _serde::__private::Option::is_some(&m_externalId) {
275 #[cfg(feature = "ignore_duplicates")]
276 {
277 __A::skip_value(&mut __map)?;
278 continue;
279 }
280 #[cfg(feature = "strict")]
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::duplicate_field(
283 "externalId",
284 ),
285 );
286 }
287 m_externalId = _serde::__private::Some(
288 match __A::next_value::<StringPtr<'de>>(&mut __map) {
289 _serde::__private::Ok(__val) => __val,
290 _serde::__private::Err(__err) => {
291 return _serde::__private::Err(__err);
292 }
293 },
294 );
295 }
296 _ => __A::skip_value(&mut __map)?,
297 }
298 }
299 let m_memberName = match m_memberName {
300 _serde::__private::Some(__field) => __field,
301 _serde::__private::None => {
302 #[cfg(feature = "strict")]
303 return _serde::__private::Err(
304 <__A::Error as _serde::de::Error>::missing_field(
305 "memberName",
306 ),
307 );
308 #[cfg(not(feature = "strict"))] Default::default()
309 }
310 };
311 let m_externalId = match m_externalId {
312 _serde::__private::Some(__field) => __field,
313 _serde::__private::None => {
314 #[cfg(feature = "strict")]
315 return _serde::__private::Err(
316 <__A::Error as _serde::de::Error>::missing_field(
317 "externalId",
318 ),
319 );
320 #[cfg(not(feature = "strict"))] Default::default()
321 }
322 };
323 let __ptr = __A::class_ptr(&mut __map);
324 _serde::__private::Ok(hkMemoryResourceHandleExternalLink {
325 __ptr,
326 m_memberName,
327 m_externalId,
328 })
329 }
330 }
331 const FIELDS: &[&str] = &["memberName", "externalId"];
332 _serde::Deserializer::deserialize_struct(
333 deserializer,
334 "hkMemoryResourceHandleExternalLink",
335 FIELDS,
336 __hkMemoryResourceHandleExternalLinkVisitor {
337 marker: _serde::__private::PhantomData::<
338 hkMemoryResourceHandleExternalLink,
339 >,
340 lifetime: _serde::__private::PhantomData,
341 },
342 )
343 }
344 }
345};