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