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 hkbVariableBindingSet<'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 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "serde", serde(borrow))]
35 #[cfg_attr(feature = "json_schema", schemars(rename = "bindings"))]
36 #[cfg_attr(feature = "serde", serde(rename = "bindings"))]
37 pub m_bindings: Vec<hkbVariableBindingSetBinding<'a>>,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "indexOfBindingToEnable"))]
43 #[cfg_attr(feature = "serde", serde(rename = "indexOfBindingToEnable"))]
44 pub m_indexOfBindingToEnable: i32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "hasOutputBinding"))]
51 #[cfg_attr(feature = "serde", serde(rename = "hasOutputBinding"))]
52 pub m_hasOutputBinding: bool,
53}
54const _: () = {
55 use havok_serde as _serde;
56 impl<'a> _serde::HavokClass for hkbVariableBindingSet<'a> {
57 #[inline]
58 fn name(&self) -> &'static str {
59 "hkbVariableBindingSet"
60 }
61 #[inline]
62 fn signature(&self) -> _serde::__private::Signature {
63 _serde::__private::Signature::new(0x338ad4ff)
64 }
65 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
66 fn deps_indexes(&self) -> Vec<usize> {
67 let mut v = Vec::new();
68 v.extend(
69 self
70 .m_bindings
71 .iter()
72 .flat_map(|class| class.deps_indexes())
73 .collect::<Vec<usize>>(),
74 );
75 v
76 }
77 }
78 impl<'a> _serde::Serialize for hkbVariableBindingSet<'a> {
79 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
80 where
81 S: _serde::ser::Serializer,
82 {
83 let class_meta = self
84 .__ptr
85 .map(|name| (name, _serde::__private::Signature::new(0x338ad4ff)));
86 let mut serializer = __serializer
87 .serialize_struct("hkbVariableBindingSet", class_meta, (28u64, 40u64))?;
88 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
89 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
90 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
91 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
92 serializer
93 .serialize_array_field(
94 "bindings",
95 &self.m_bindings,
96 TypeSize::Struct {
97 size_x86: 32u64,
98 size_x86_64: 40u64,
99 },
100 )?;
101 serializer
102 .serialize_field(
103 "indexOfBindingToEnable",
104 &self.m_indexOfBindingToEnable,
105 )?;
106 serializer.skip_field("hasOutputBinding", &self.m_hasOutputBinding)?;
107 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
108 serializer.end()
109 }
110 }
111};
112#[doc(hidden)]
113#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
114const _: () = {
115 use havok_serde as _serde;
116 #[automatically_derived]
117 impl<'de> _serde::Deserialize<'de> for hkbVariableBindingSet<'de> {
118 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
119 where
120 __D: _serde::Deserializer<'de>,
121 {
122 #[allow(non_camel_case_types)]
123 enum __Field {
124 m_bindings,
125 m_indexOfBindingToEnable,
126 __ignore,
127 }
128 struct __FieldVisitor;
129 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
130 type Value = __Field;
131 fn expecting(
132 &self,
133 __formatter: &mut core::fmt::Formatter,
134 ) -> core::fmt::Result {
135 core::fmt::Formatter::write_str(__formatter, "field identifier")
136 }
137 #[allow(clippy::match_single_binding)]
139 #[allow(clippy::reversed_empty_ranges)]
140 #[allow(clippy::single_match)]
141 fn visit_key<__E>(
142 self,
143 __value: &str,
144 ) -> core::result::Result<Self::Value, __E>
145 where
146 __E: _serde::de::Error,
147 {
148 match __value {
149 "bindings" => Ok(__Field::m_bindings),
150 "indexOfBindingToEnable" => Ok(__Field::m_indexOfBindingToEnable),
151 _ => Ok(__Field::__ignore),
152 }
153 }
154 }
155 impl<'de> _serde::Deserialize<'de> for __Field {
156 #[inline]
157 fn deserialize<__D>(
158 __deserializer: __D,
159 ) -> core::result::Result<Self, __D::Error>
160 where
161 __D: _serde::Deserializer<'de>,
162 {
163 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
164 }
165 }
166 struct __hkbVariableBindingSetVisitor<'de> {
167 marker: _serde::__private::PhantomData<hkbVariableBindingSet<'de>>,
168 lifetime: _serde::__private::PhantomData<&'de ()>,
169 }
170 #[allow(clippy::match_single_binding)]
171 #[allow(clippy::reversed_empty_ranges)]
172 #[allow(clippy::single_match)]
173 impl<'de> _serde::de::Visitor<'de> for __hkbVariableBindingSetVisitor<'de> {
174 type Value = hkbVariableBindingSet<'de>;
175 fn expecting(
176 &self,
177 __formatter: &mut core::fmt::Formatter,
178 ) -> core::fmt::Result {
179 core::fmt::Formatter::write_str(
180 __formatter,
181 "struct hkbVariableBindingSet",
182 )
183 }
184 fn visit_struct_for_bytes<__A>(
185 self,
186 mut __map: __A,
187 ) -> _serde::__private::Result<Self::Value, __A::Error>
188 where
189 __A: _serde::de::MapAccess<'de>,
190 {
191 let __ptr = __A::class_ptr(&mut __map);
192 let parent = __A::parent_value(&mut __map)?;
193 let mut m_bindings: _serde::__private::Option<
194 Vec<hkbVariableBindingSetBinding<'de>>,
195 > = _serde::__private::None;
196 let mut m_indexOfBindingToEnable: _serde::__private::Option<i32> = _serde::__private::None;
197 let mut m_hasOutputBinding: _serde::__private::Option<bool> = _serde::__private::None;
198 for i in 0..3usize {
199 match i {
200 0usize => {
201 if _serde::__private::Option::is_some(&m_bindings) {
202 return _serde::__private::Err(
203 <__A::Error as _serde::de::Error>::duplicate_field(
204 "bindings",
205 ),
206 );
207 }
208 m_bindings = _serde::__private::Some(
209 match __A::next_value::<
210 Vec<hkbVariableBindingSetBinding<'de>>,
211 >(&mut __map) {
212 _serde::__private::Ok(__val) => __val,
213 _serde::__private::Err(__err) => {
214 return _serde::__private::Err(__err);
215 }
216 },
217 );
218 }
219 1usize => {
220 if _serde::__private::Option::is_some(
221 &m_indexOfBindingToEnable,
222 ) {
223 return _serde::__private::Err(
224 <__A::Error as _serde::de::Error>::duplicate_field(
225 "indexOfBindingToEnable",
226 ),
227 );
228 }
229 m_indexOfBindingToEnable = _serde::__private::Some(
230 match __A::next_value::<i32>(&mut __map) {
231 _serde::__private::Ok(__val) => __val,
232 _serde::__private::Err(__err) => {
233 return _serde::__private::Err(__err);
234 }
235 },
236 );
237 }
238 2usize => {
239 if _serde::__private::Option::is_some(&m_hasOutputBinding) {
240 return _serde::__private::Err(
241 <__A::Error as _serde::de::Error>::duplicate_field(
242 "hasOutputBinding",
243 ),
244 );
245 }
246 m_hasOutputBinding = _serde::__private::Some(
247 match __A::next_value::<bool>(&mut __map) {
248 _serde::__private::Ok(__val) => __val,
249 _serde::__private::Err(__err) => {
250 return _serde::__private::Err(__err);
251 }
252 },
253 );
254 }
255 _ => {}
256 }
257 }
258 __A::pad(&mut __map, 3usize, 3usize)?;
259 let m_bindings = match m_bindings {
260 _serde::__private::Some(__field) => __field,
261 _serde::__private::None => {
262 return _serde::__private::Err(
263 <__A::Error as _serde::de::Error>::missing_field("bindings"),
264 );
265 }
266 };
267 let m_indexOfBindingToEnable = match m_indexOfBindingToEnable {
268 _serde::__private::Some(__field) => __field,
269 _serde::__private::None => {
270 return _serde::__private::Err(
271 <__A::Error as _serde::de::Error>::missing_field(
272 "indexOfBindingToEnable",
273 ),
274 );
275 }
276 };
277 let m_hasOutputBinding = match m_hasOutputBinding {
278 _serde::__private::Some(__field) => __field,
279 _serde::__private::None => {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::missing_field(
282 "hasOutputBinding",
283 ),
284 );
285 }
286 };
287 _serde::__private::Ok(hkbVariableBindingSet {
288 __ptr,
289 parent,
290 m_bindings,
291 m_indexOfBindingToEnable,
292 m_hasOutputBinding,
293 })
294 }
295 #[allow(clippy::manual_unwrap_or_default)]
296 fn visit_struct<__A>(
297 self,
298 mut __map: __A,
299 ) -> _serde::__private::Result<Self::Value, __A::Error>
300 where
301 __A: _serde::de::MapAccess<'de>,
302 {
303 let mut m_bindings: _serde::__private::Option<
304 Vec<hkbVariableBindingSetBinding<'de>>,
305 > = _serde::__private::None;
306 let mut m_indexOfBindingToEnable: _serde::__private::Option<i32> = _serde::__private::None;
307 while let _serde::__private::Some(__key) = {
308 __A::next_key::<__Field>(&mut __map)?
309 } {
310 match __key {
311 __Field::m_bindings => {
312 #[cfg(
313 any(feature = "strict", feature = "ignore_duplicates")
314 )]
315 if _serde::__private::Option::is_some(&m_bindings) {
316 #[cfg(feature = "ignore_duplicates")]
317 {
318 __A::skip_value(&mut __map)?;
319 continue;
320 }
321 #[cfg(feature = "strict")]
322 return _serde::__private::Err(
323 <__A::Error as _serde::de::Error>::duplicate_field(
324 "bindings",
325 ),
326 );
327 }
328 m_bindings = _serde::__private::Some(
329 match __A::next_value::<
330 Vec<hkbVariableBindingSetBinding<'de>>,
331 >(&mut __map) {
332 _serde::__private::Ok(__val) => __val,
333 _serde::__private::Err(__err) => {
334 return _serde::__private::Err(__err);
335 }
336 },
337 );
338 }
339 __Field::m_indexOfBindingToEnable => {
340 #[cfg(
341 any(feature = "strict", feature = "ignore_duplicates")
342 )]
343 if _serde::__private::Option::is_some(
344 &m_indexOfBindingToEnable,
345 ) {
346 #[cfg(feature = "ignore_duplicates")]
347 {
348 __A::skip_value(&mut __map)?;
349 continue;
350 }
351 #[cfg(feature = "strict")]
352 return _serde::__private::Err(
353 <__A::Error as _serde::de::Error>::duplicate_field(
354 "indexOfBindingToEnable",
355 ),
356 );
357 }
358 m_indexOfBindingToEnable = _serde::__private::Some(
359 match __A::next_value::<i32>(&mut __map) {
360 _serde::__private::Ok(__val) => __val,
361 _serde::__private::Err(__err) => {
362 return _serde::__private::Err(__err);
363 }
364 },
365 );
366 }
367 _ => __A::skip_value(&mut __map)?,
368 }
369 }
370 let m_bindings = match m_bindings {
371 _serde::__private::Some(__field) => __field,
372 _serde::__private::None => {
373 #[cfg(feature = "strict")]
374 return _serde::__private::Err(
375 <__A::Error as _serde::de::Error>::missing_field("bindings"),
376 );
377 #[cfg(not(feature = "strict"))] Default::default()
378 }
379 };
380 let m_indexOfBindingToEnable = match m_indexOfBindingToEnable {
381 _serde::__private::Some(__field) => __field,
382 _serde::__private::None => {
383 #[cfg(feature = "strict")]
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::missing_field(
386 "indexOfBindingToEnable",
387 ),
388 );
389 #[cfg(not(feature = "strict"))] Default::default()
390 }
391 };
392 let __ptr = None;
393 let parent = hkBaseObject { __ptr };
394 let parent = hkReferencedObject {
395 __ptr,
396 parent,
397 ..Default::default()
398 };
399 let __ptr = __A::class_ptr(&mut __map);
400 _serde::__private::Ok(hkbVariableBindingSet {
401 __ptr,
402 parent,
403 m_bindings,
404 m_indexOfBindingToEnable,
405 ..Default::default()
406 })
407 }
408 }
409 const FIELDS: &[&str] = &[
410 "bindings",
411 "indexOfBindingToEnable",
412 "hasOutputBinding",
413 ];
414 _serde::Deserializer::deserialize_struct(
415 deserializer,
416 "hkbVariableBindingSet",
417 FIELDS,
418 __hkbVariableBindingSetVisitor {
419 marker: _serde::__private::PhantomData::<hkbVariableBindingSet>,
420 lifetime: _serde::__private::PhantomData,
421 },
422 )
423 }
424 }
425};