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