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