havok_classes/generated/
hkpStiffSpringChainData_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkpStiffSpringChainData`
5/// - version: `0`
6/// - signature: `0xf170356b`
7/// - size: ` 48`(x86)/` 80`(x86_64)
8/// -  vtable: `true`
9#[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 hkpStiffSpringChainData {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkpConstraintChainData,
30    /// # C++ Info
31    /// - name: `atoms`(ctype: `struct hkpBridgeAtoms`)
32    /// - offset: ` 12`(x86)/` 24`(x86_64)
33    /// - type_size: ` 12`(x86)/` 24`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "atoms"))]
35    #[cfg_attr(feature = "serde", serde(rename = "atoms"))]
36    pub m_atoms: hkpBridgeAtoms,
37    /// # C++ Info
38    /// - name: `infos`(ctype: `hkArray<struct hkpStiffSpringChainDataConstraintInfo>`)
39    /// - offset: ` 24`(x86)/` 48`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "infos"))]
42    #[cfg_attr(feature = "serde", serde(rename = "infos"))]
43    pub m_infos: Vec<hkpStiffSpringChainDataConstraintInfo>,
44    /// # C++ Info
45    /// - name: `tau`(ctype: `hkReal`)
46    /// - offset: ` 36`(x86)/` 64`(x86_64)
47    /// - type_size: `  4`(x86)/`  4`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "tau"))]
49    #[cfg_attr(feature = "serde", serde(rename = "tau"))]
50    pub m_tau: f32,
51    /// # C++ Info
52    /// - name: `damping`(ctype: `hkReal`)
53    /// - offset: ` 40`(x86)/` 68`(x86_64)
54    /// - type_size: `  4`(x86)/`  4`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "damping"))]
56    #[cfg_attr(feature = "serde", serde(rename = "damping"))]
57    pub m_damping: f32,
58    /// # C++ Info
59    /// - name: `cfm`(ctype: `hkReal`)
60    /// - offset: ` 44`(x86)/` 72`(x86_64)
61    /// - type_size: `  4`(x86)/`  4`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "cfm"))]
63    #[cfg_attr(feature = "serde", serde(rename = "cfm"))]
64    pub m_cfm: f32,
65}
66const _: () = {
67    use havok_serde as _serde;
68    impl _serde::HavokClass for hkpStiffSpringChainData {
69        #[inline]
70        fn name(&self) -> &'static str {
71            "hkpStiffSpringChainData"
72        }
73        #[inline]
74        fn signature(&self) -> _serde::__private::Signature {
75            _serde::__private::Signature::new(0xf170356b)
76        }
77        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
78        fn deps_indexes(&self) -> Vec<usize> {
79            let mut v = Vec::new();
80            v.extend(self.m_atoms.deps_indexes());
81            v.extend(
82                self
83                    .m_infos
84                    .iter()
85                    .flat_map(|class| class.deps_indexes())
86                    .collect::<Vec<usize>>(),
87            );
88            v
89        }
90    }
91    impl _serde::Serialize for hkpStiffSpringChainData {
92        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
93        where
94            S: _serde::ser::Serializer,
95        {
96            let class_meta = self
97                .__ptr
98                .map(|name| (name, _serde::__private::Signature::new(0xf170356b)));
99            let mut serializer = __serializer
100                .serialize_struct(
101                    "hkpStiffSpringChainData",
102                    class_meta,
103                    (48u64, 80u64),
104                )?;
105            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
106            serializer
107                .skip_field(
108                    "memSizeAndFlags",
109                    &self.parent.parent.parent.m_memSizeAndFlags,
110                )?;
111            serializer
112                .skip_field(
113                    "referenceCount",
114                    &self.parent.parent.parent.m_referenceCount,
115                )?;
116            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
117            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
118            serializer.serialize_field("atoms", &self.m_atoms)?;
119            serializer
120                .serialize_array_field(
121                    "infos",
122                    &self.m_infos,
123                    TypeSize::Struct {
124                        size_x86: 48u64,
125                        size_x86_64: 48u64,
126                    },
127                )?;
128            serializer.serialize_field("tau", &self.m_tau)?;
129            serializer.serialize_field("damping", &self.m_damping)?;
130            serializer.serialize_field("cfm", &self.m_cfm)?;
131            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
132            serializer.end()
133        }
134    }
135};
136#[doc(hidden)]
137#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
138const _: () = {
139    use havok_serde as _serde;
140    #[automatically_derived]
141    impl<'de> _serde::Deserialize<'de> for hkpStiffSpringChainData {
142        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
143        where
144            __D: _serde::Deserializer<'de>,
145        {
146            #[allow(non_camel_case_types)]
147            enum __Field {
148                m_userData,
149                m_atoms,
150                m_infos,
151                m_tau,
152                m_damping,
153                m_cfm,
154                __ignore,
155            }
156            struct __FieldVisitor;
157            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
158                type Value = __Field;
159                fn expecting(
160                    &self,
161                    __formatter: &mut core::fmt::Formatter,
162                ) -> core::fmt::Result {
163                    core::fmt::Formatter::write_str(__formatter, "field identifier")
164                }
165                /// Intended for use in XML.
166                #[allow(clippy::match_single_binding)]
167                #[allow(clippy::reversed_empty_ranges)]
168                #[allow(clippy::single_match)]
169                fn visit_key<__E>(
170                    self,
171                    __value: &str,
172                ) -> core::result::Result<Self::Value, __E>
173                where
174                    __E: _serde::de::Error,
175                {
176                    match __value {
177                        "userData" => Ok(__Field::m_userData),
178                        "atoms" => Ok(__Field::m_atoms),
179                        "infos" => Ok(__Field::m_infos),
180                        "tau" => Ok(__Field::m_tau),
181                        "damping" => Ok(__Field::m_damping),
182                        "cfm" => Ok(__Field::m_cfm),
183                        _ => Ok(__Field::__ignore),
184                    }
185                }
186            }
187            impl<'de> _serde::Deserialize<'de> for __Field {
188                #[inline]
189                fn deserialize<__D>(
190                    __deserializer: __D,
191                ) -> core::result::Result<Self, __D::Error>
192                where
193                    __D: _serde::Deserializer<'de>,
194                {
195                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
196                }
197            }
198            struct __hkpStiffSpringChainDataVisitor<'de> {
199                marker: _serde::__private::PhantomData<hkpStiffSpringChainData>,
200                lifetime: _serde::__private::PhantomData<&'de ()>,
201            }
202            #[allow(clippy::match_single_binding)]
203            #[allow(clippy::reversed_empty_ranges)]
204            #[allow(clippy::single_match)]
205            impl<'de> _serde::de::Visitor<'de>
206            for __hkpStiffSpringChainDataVisitor<'de> {
207                type Value = hkpStiffSpringChainData;
208                fn expecting(
209                    &self,
210                    __formatter: &mut core::fmt::Formatter,
211                ) -> core::fmt::Result {
212                    core::fmt::Formatter::write_str(
213                        __formatter,
214                        "struct hkpStiffSpringChainData",
215                    )
216                }
217                fn visit_struct_for_bytes<__A>(
218                    self,
219                    mut __map: __A,
220                ) -> _serde::__private::Result<Self::Value, __A::Error>
221                where
222                    __A: _serde::de::MapAccess<'de>,
223                {
224                    let __ptr = __A::class_ptr(&mut __map);
225                    let parent = __A::parent_value(&mut __map)?;
226                    let mut m_atoms: _serde::__private::Option<hkpBridgeAtoms> = _serde::__private::None;
227                    let mut m_infos: _serde::__private::Option<
228                        Vec<hkpStiffSpringChainDataConstraintInfo>,
229                    > = _serde::__private::None;
230                    let mut m_tau: _serde::__private::Option<f32> = _serde::__private::None;
231                    let mut m_damping: _serde::__private::Option<f32> = _serde::__private::None;
232                    let mut m_cfm: _serde::__private::Option<f32> = _serde::__private::None;
233                    for i in 0..5usize {
234                        match i {
235                            0usize => {
236                                if _serde::__private::Option::is_some(&m_atoms) {
237                                    return _serde::__private::Err(
238                                        <__A::Error as _serde::de::Error>::duplicate_field("atoms"),
239                                    );
240                                }
241                                m_atoms = _serde::__private::Some(
242                                    match __A::next_value::<hkpBridgeAtoms>(&mut __map) {
243                                        _serde::__private::Ok(__val) => __val,
244                                        _serde::__private::Err(__err) => {
245                                            return _serde::__private::Err(__err);
246                                        }
247                                    },
248                                );
249                            }
250                            1usize => {
251                                if _serde::__private::Option::is_some(&m_infos) {
252                                    return _serde::__private::Err(
253                                        <__A::Error as _serde::de::Error>::duplicate_field("infos"),
254                                    );
255                                }
256                                m_infos = _serde::__private::Some(
257                                    match __A::next_value::<
258                                        Vec<hkpStiffSpringChainDataConstraintInfo>,
259                                    >(&mut __map) {
260                                        _serde::__private::Ok(__val) => __val,
261                                        _serde::__private::Err(__err) => {
262                                            return _serde::__private::Err(__err);
263                                        }
264                                    },
265                                );
266                            }
267                            2usize => {
268                                if _serde::__private::Option::is_some(&m_tau) {
269                                    return _serde::__private::Err(
270                                        <__A::Error as _serde::de::Error>::duplicate_field("tau"),
271                                    );
272                                }
273                                m_tau = _serde::__private::Some(
274                                    match __A::next_value::<f32>(&mut __map) {
275                                        _serde::__private::Ok(__val) => __val,
276                                        _serde::__private::Err(__err) => {
277                                            return _serde::__private::Err(__err);
278                                        }
279                                    },
280                                );
281                            }
282                            3usize => {
283                                if _serde::__private::Option::is_some(&m_damping) {
284                                    return _serde::__private::Err(
285                                        <__A::Error as _serde::de::Error>::duplicate_field(
286                                            "damping",
287                                        ),
288                                    );
289                                }
290                                m_damping = _serde::__private::Some(
291                                    match __A::next_value::<f32>(&mut __map) {
292                                        _serde::__private::Ok(__val) => __val,
293                                        _serde::__private::Err(__err) => {
294                                            return _serde::__private::Err(__err);
295                                        }
296                                    },
297                                );
298                            }
299                            4usize => {
300                                if _serde::__private::Option::is_some(&m_cfm) {
301                                    return _serde::__private::Err(
302                                        <__A::Error as _serde::de::Error>::duplicate_field("cfm"),
303                                    );
304                                }
305                                m_cfm = _serde::__private::Some(
306                                    match __A::next_value::<f32>(&mut __map) {
307                                        _serde::__private::Ok(__val) => __val,
308                                        _serde::__private::Err(__err) => {
309                                            return _serde::__private::Err(__err);
310                                        }
311                                    },
312                                );
313                            }
314                            _ => {}
315                        }
316                    }
317                    __A::pad(&mut __map, 0usize, 4usize)?;
318                    let m_atoms = match m_atoms {
319                        _serde::__private::Some(__field) => __field,
320                        _serde::__private::None => {
321                            return _serde::__private::Err(
322                                <__A::Error as _serde::de::Error>::missing_field("atoms"),
323                            );
324                        }
325                    };
326                    let m_infos = match m_infos {
327                        _serde::__private::Some(__field) => __field,
328                        _serde::__private::None => {
329                            return _serde::__private::Err(
330                                <__A::Error as _serde::de::Error>::missing_field("infos"),
331                            );
332                        }
333                    };
334                    let m_tau = match m_tau {
335                        _serde::__private::Some(__field) => __field,
336                        _serde::__private::None => {
337                            return _serde::__private::Err(
338                                <__A::Error as _serde::de::Error>::missing_field("tau"),
339                            );
340                        }
341                    };
342                    let m_damping = match m_damping {
343                        _serde::__private::Some(__field) => __field,
344                        _serde::__private::None => {
345                            return _serde::__private::Err(
346                                <__A::Error as _serde::de::Error>::missing_field("damping"),
347                            );
348                        }
349                    };
350                    let m_cfm = match m_cfm {
351                        _serde::__private::Some(__field) => __field,
352                        _serde::__private::None => {
353                            return _serde::__private::Err(
354                                <__A::Error as _serde::de::Error>::missing_field("cfm"),
355                            );
356                        }
357                    };
358                    _serde::__private::Ok(hkpStiffSpringChainData {
359                        __ptr,
360                        parent,
361                        m_atoms,
362                        m_infos,
363                        m_tau,
364                        m_damping,
365                        m_cfm,
366                    })
367                }
368                #[allow(clippy::manual_unwrap_or_default)]
369                fn visit_struct<__A>(
370                    self,
371                    mut __map: __A,
372                ) -> _serde::__private::Result<Self::Value, __A::Error>
373                where
374                    __A: _serde::de::MapAccess<'de>,
375                {
376                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
377                    let mut m_atoms: _serde::__private::Option<hkpBridgeAtoms> = _serde::__private::None;
378                    let mut m_infos: _serde::__private::Option<
379                        Vec<hkpStiffSpringChainDataConstraintInfo>,
380                    > = _serde::__private::None;
381                    let mut m_tau: _serde::__private::Option<f32> = _serde::__private::None;
382                    let mut m_damping: _serde::__private::Option<f32> = _serde::__private::None;
383                    let mut m_cfm: _serde::__private::Option<f32> = _serde::__private::None;
384                    while let _serde::__private::Some(__key) = {
385                        __A::next_key::<__Field>(&mut __map)?
386                    } {
387                        match __key {
388                            __Field::m_userData => {
389                                #[cfg(
390                                    any(feature = "strict", feature = "ignore_duplicates")
391                                )]
392                                if _serde::__private::Option::is_some(&m_userData) {
393                                    #[cfg(feature = "ignore_duplicates")]
394                                    {
395                                        __A::skip_value(&mut __map)?;
396                                        continue;
397                                    }
398                                    #[cfg(feature = "strict")]
399                                    return _serde::__private::Err(
400                                        <__A::Error as _serde::de::Error>::duplicate_field(
401                                            "userData",
402                                        ),
403                                    );
404                                }
405                                m_userData = _serde::__private::Some(
406                                    match __A::next_value::<Ulong>(&mut __map) {
407                                        _serde::__private::Ok(__val) => __val,
408                                        _serde::__private::Err(__err) => {
409                                            return _serde::__private::Err(__err);
410                                        }
411                                    },
412                                );
413                            }
414                            __Field::m_atoms => {
415                                #[cfg(
416                                    any(feature = "strict", feature = "ignore_duplicates")
417                                )]
418                                if _serde::__private::Option::is_some(&m_atoms) {
419                                    #[cfg(feature = "ignore_duplicates")]
420                                    {
421                                        __A::skip_value(&mut __map)?;
422                                        continue;
423                                    }
424                                    #[cfg(feature = "strict")]
425                                    return _serde::__private::Err(
426                                        <__A::Error as _serde::de::Error>::duplicate_field("atoms"),
427                                    );
428                                }
429                                m_atoms = _serde::__private::Some(
430                                    match __A::next_value::<hkpBridgeAtoms>(&mut __map) {
431                                        _serde::__private::Ok(__val) => __val,
432                                        _serde::__private::Err(__err) => {
433                                            return _serde::__private::Err(__err);
434                                        }
435                                    },
436                                );
437                            }
438                            __Field::m_infos => {
439                                #[cfg(
440                                    any(feature = "strict", feature = "ignore_duplicates")
441                                )]
442                                if _serde::__private::Option::is_some(&m_infos) {
443                                    #[cfg(feature = "ignore_duplicates")]
444                                    {
445                                        __A::skip_value(&mut __map)?;
446                                        continue;
447                                    }
448                                    #[cfg(feature = "strict")]
449                                    return _serde::__private::Err(
450                                        <__A::Error as _serde::de::Error>::duplicate_field("infos"),
451                                    );
452                                }
453                                m_infos = _serde::__private::Some(
454                                    match __A::next_value::<
455                                        Vec<hkpStiffSpringChainDataConstraintInfo>,
456                                    >(&mut __map) {
457                                        _serde::__private::Ok(__val) => __val,
458                                        _serde::__private::Err(__err) => {
459                                            return _serde::__private::Err(__err);
460                                        }
461                                    },
462                                );
463                            }
464                            __Field::m_tau => {
465                                #[cfg(
466                                    any(feature = "strict", feature = "ignore_duplicates")
467                                )]
468                                if _serde::__private::Option::is_some(&m_tau) {
469                                    #[cfg(feature = "ignore_duplicates")]
470                                    {
471                                        __A::skip_value(&mut __map)?;
472                                        continue;
473                                    }
474                                    #[cfg(feature = "strict")]
475                                    return _serde::__private::Err(
476                                        <__A::Error as _serde::de::Error>::duplicate_field("tau"),
477                                    );
478                                }
479                                m_tau = _serde::__private::Some(
480                                    match __A::next_value::<f32>(&mut __map) {
481                                        _serde::__private::Ok(__val) => __val,
482                                        _serde::__private::Err(__err) => {
483                                            return _serde::__private::Err(__err);
484                                        }
485                                    },
486                                );
487                            }
488                            __Field::m_damping => {
489                                #[cfg(
490                                    any(feature = "strict", feature = "ignore_duplicates")
491                                )]
492                                if _serde::__private::Option::is_some(&m_damping) {
493                                    #[cfg(feature = "ignore_duplicates")]
494                                    {
495                                        __A::skip_value(&mut __map)?;
496                                        continue;
497                                    }
498                                    #[cfg(feature = "strict")]
499                                    return _serde::__private::Err(
500                                        <__A::Error as _serde::de::Error>::duplicate_field(
501                                            "damping",
502                                        ),
503                                    );
504                                }
505                                m_damping = _serde::__private::Some(
506                                    match __A::next_value::<f32>(&mut __map) {
507                                        _serde::__private::Ok(__val) => __val,
508                                        _serde::__private::Err(__err) => {
509                                            return _serde::__private::Err(__err);
510                                        }
511                                    },
512                                );
513                            }
514                            __Field::m_cfm => {
515                                #[cfg(
516                                    any(feature = "strict", feature = "ignore_duplicates")
517                                )]
518                                if _serde::__private::Option::is_some(&m_cfm) {
519                                    #[cfg(feature = "ignore_duplicates")]
520                                    {
521                                        __A::skip_value(&mut __map)?;
522                                        continue;
523                                    }
524                                    #[cfg(feature = "strict")]
525                                    return _serde::__private::Err(
526                                        <__A::Error as _serde::de::Error>::duplicate_field("cfm"),
527                                    );
528                                }
529                                m_cfm = _serde::__private::Some(
530                                    match __A::next_value::<f32>(&mut __map) {
531                                        _serde::__private::Ok(__val) => __val,
532                                        _serde::__private::Err(__err) => {
533                                            return _serde::__private::Err(__err);
534                                        }
535                                    },
536                                );
537                            }
538                            _ => __A::skip_value(&mut __map)?,
539                        }
540                    }
541                    let m_userData = match m_userData {
542                        _serde::__private::Some(__field) => __field,
543                        _serde::__private::None => {
544                            #[cfg(feature = "strict")]
545                            return _serde::__private::Err(
546                                <__A::Error as _serde::de::Error>::missing_field("userData"),
547                            );
548                            #[cfg(not(feature = "strict"))] Default::default()
549                        }
550                    };
551                    let m_atoms = match m_atoms {
552                        _serde::__private::Some(__field) => __field,
553                        _serde::__private::None => {
554                            #[cfg(feature = "strict")]
555                            return _serde::__private::Err(
556                                <__A::Error as _serde::de::Error>::missing_field("atoms"),
557                            );
558                            #[cfg(not(feature = "strict"))] Default::default()
559                        }
560                    };
561                    let m_infos = match m_infos {
562                        _serde::__private::Some(__field) => __field,
563                        _serde::__private::None => {
564                            #[cfg(feature = "strict")]
565                            return _serde::__private::Err(
566                                <__A::Error as _serde::de::Error>::missing_field("infos"),
567                            );
568                            #[cfg(not(feature = "strict"))] Default::default()
569                        }
570                    };
571                    let m_tau = match m_tau {
572                        _serde::__private::Some(__field) => __field,
573                        _serde::__private::None => {
574                            #[cfg(feature = "strict")]
575                            return _serde::__private::Err(
576                                <__A::Error as _serde::de::Error>::missing_field("tau"),
577                            );
578                            #[cfg(not(feature = "strict"))] Default::default()
579                        }
580                    };
581                    let m_damping = match m_damping {
582                        _serde::__private::Some(__field) => __field,
583                        _serde::__private::None => {
584                            #[cfg(feature = "strict")]
585                            return _serde::__private::Err(
586                                <__A::Error as _serde::de::Error>::missing_field("damping"),
587                            );
588                            #[cfg(not(feature = "strict"))] Default::default()
589                        }
590                    };
591                    let m_cfm = match m_cfm {
592                        _serde::__private::Some(__field) => __field,
593                        _serde::__private::None => {
594                            #[cfg(feature = "strict")]
595                            return _serde::__private::Err(
596                                <__A::Error as _serde::de::Error>::missing_field("cfm"),
597                            );
598                            #[cfg(not(feature = "strict"))] Default::default()
599                        }
600                    };
601                    let __ptr = None;
602                    let parent = hkBaseObject { __ptr };
603                    let parent = hkReferencedObject {
604                        __ptr,
605                        parent,
606                        ..Default::default()
607                    };
608                    let parent = hkpConstraintData {
609                        __ptr,
610                        parent,
611                        m_userData,
612                    };
613                    let parent = hkpConstraintChainData {
614                        __ptr,
615                        parent,
616                    };
617                    let __ptr = __A::class_ptr(&mut __map);
618                    _serde::__private::Ok(hkpStiffSpringChainData {
619                        __ptr,
620                        parent,
621                        m_atoms,
622                        m_infos,
623                        m_tau,
624                        m_damping,
625                        m_cfm,
626                    })
627                }
628            }
629            const FIELDS: &[&str] = &["atoms", "infos", "tau", "damping", "cfm"];
630            _serde::Deserializer::deserialize_struct(
631                deserializer,
632                "hkpStiffSpringChainData",
633                FIELDS,
634                __hkpStiffSpringChainDataVisitor {
635                    marker: _serde::__private::PhantomData::<hkpStiffSpringChainData>,
636                    lifetime: _serde::__private::PhantomData,
637                },
638            )
639        }
640    }
641};
havok_classes/generated/hkpStiffSpringChainData_.rs

havok_classes/generated/
hkpStiffSpringChainData_.rs
