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