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