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