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