Struct XmlSerializer 

pub struct XmlSerializer {
    pub output: String,
    pub indent: &'static str,
    pub depth: usize,
    pub start_root: Option<&'static str>,
    pub end_root: Option<&'static str>,
}

Fields

output: String

XML string

indent: &'static str

Indent type(tab: \t, space: . default: \t)

depth: usize

Indent time

start_root: Option<&'static str>

If you want to output XML partially, put Option::None.

Example XML

<?xml version="1.0" encoding="ascii"?>
<hkpackfile classversion="8" contentsversion="hk_2010.2.0-r1" toplevelobject=""

end_root: Option<&'static str>

If you want to output XML partially, put Option::None.

Example XML

</hkpackfile>

Trait Implementations

impl Debug for XmlSerializer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for XmlSerializer

fn default() -> Self

Returns the “default value” for a type.

impl SerializeFlags for &mut XmlSerializer

fn serialize_empty_bit(&mut self) -> Result<(), Self::Error>

e.g. 0

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_field<T>( &mut self, key: &str, _value: &T, ) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Serialize a enum or bit field.(Only used by XML serializer.)

fn end(self) -> Result<Self::Ok, Self::Error>

Finish serializing flags.

fn serialize_bits<T>(&mut self, value: &T) -> Result<(), Self::Error>

where T: Serialize + ?Sized,

Serialize all bits of a flag.(Only used by binary serializer.)

impl SerializeSeq for &mut XmlSerializer

fn serialize_primitive_element<T>( &mut self, value: &T, index: usize, len: usize, ) -> Result<(), Self::Error>

where T: ?Sized + Serialize,

Expected XML Examples

• hkArray<hkInt8>(same as ptr, hkReal, etc…)

<hkparam name="key" numelements="20">
    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    16 17 18 19 20
</hkparam>

fn serialize_cstring_element(&mut self, value: &CString<'_>) -> Result<()>

XML Examples

    <hkcstring>CString</hkcstring>

fn serialize_stringptr_element(&mut self, value: &StringPtr<'_>) -> Result<()>

XML Examples

    <hkcstring>StringPtr</hkcstring>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_class_element<T>(&mut self, value: &T) -> Result<()>

where T: ?Sized + Serialize,

Serialize a Havok Class sequence element.(e.g. T: impl HavokClass)

fn serialize_math_element<T>(&mut self, value: &T) -> Result<()>

where T: ?Sized + Serialize,

Serialize a math sequence element.(e.g. Matrix3)

fn end(self) -> Result<()>

Finish serializing a sequence.

impl SerializeStruct for &mut XmlSerializer

fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>

where T: ?Sized + Serialize,

XML Examples

<hkparam name="key1">value</hkparam>

fn serialize_array_field<V, T>( &mut self, key: &'static str, value: V, _size: TypeSize, ) -> Result<()>

where V: AsRef<[T]> + Serialize, T: Serialize,

XML Examples

• hkArray<hkInt8>(same as ptr, hkReal, etc…)

<hkparam name="key" numelements="20">
    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    16 17 18 19 20
</hkparam>

• hkArray<hkStringPtr>

<hkparam name="key" numelements="3">
    <hkcstring>StringPtr1</hkcstring>
    <hkcstring>StringPtr2</hkcstring>
    <hkcstring>StringPtr3</hkcstring>
</hkparam>

• hkArray<Vector4>

<hkparam name="key" numelements="2">
    (0.000000 0.000000 0.000000 0.000000)
    (0.000000 0.000000 0.000000 0.000000)
</hkparam>

fn skip_field<T>(&mut self, key: &'static str, _: &T) -> Result<()>

where T: ?Sized + Serialize,

XML Examples

<!-- key SERIALIZE_IGNORED --><!-- This is skip_field -->
<hkparam name="otherKey"></hkparam>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_fixed_array_field<V, T>( &mut self, key: &'static str, value: V, size: TypeSize, ) -> Result<(), Self::Error>

where V: AsRef<[T]> + Serialize, T: Serialize,

Serialize a struct field for fixed array.

fn end(self) -> Result<()>

Finish serializing a struct.

fn pad_field<T>( &mut self, x86_pads: &T, x64_pads: &T, ) -> Result<(), Self::Error>

where T: AsRef<[u8]> + ?Sized,

Processing for padding to serialize binary data

fn skip_fixed_array_field<V, T>( &mut self, key: &'static str, value: V, size: TypeSize, ) -> Result<(), Self::Error>

where V: AsRef<[T]> + Serialize, T: Serialize,

Process for fields with SERIALIZE_IGNORED flag.

fn skip_array_field<V, T>( &mut self, key: &'static str, value: V, size: TypeSize, ) -> Result<(), Self::Error>

where V: AsRef<[T]> + Serialize, T: Serialize,

Process for fields with SERIALIZE_IGNORED flag.

impl Serializer for &mut XmlSerializer

fn serialize_struct( self, name: &'static str, class_meta: Option<(Pointer, Signature)>, _sizes: (u64, u64), ) -> Result<Self::SerializeStruct>

Create an XML string like the following

<hkobject name="#0010" class="hkbProjectData" signature="0x13a39ba7">
  <!-- memSizeAndFlags SERIALIZE_IGNORED -->
  <!-- referenceCount SERIALIZE_IGNORED -->
  <hkparam name="worldUpWS">(0.000000 0.000000 1.000000 0.000000)</hkparam>
  <hkparam name="stringData">#0009</hkparam>
  <hkparam name="defaultEventMode">EVENT_MODE_IGNORE_FROM_GENERATOR</hkparam>
</hkobject>

fn serialize_variant(self, v: &Variant) -> Result<Self::Ok>

FIXME: Unclear XML representation

type Ok = ()

The output type produced by this Serializer during successful serialization. Most serializers that produce text or binary output should set Ok = () and serialize into an io::Write or buffer contained within the Serializer instance. Serializers that build in-memory data structures may be simplified by using Ok to propagate the data structure around.

type Error = Error

The error type when some error occurs during serialization.

type SerializeSeq = &mut XmlSerializer

Type returned from serialize_seq for serializing the content of the sequence.

type SerializeStruct = &mut XmlSerializer

type SerializeFlags = &mut XmlSerializer

Type returned from serialize_enum_flags for serializing the content of the struct variant.

fn serialize_void(self, _: ()) -> Result<Self::Ok>

Serialize a Void value.

fn serialize_bool(self, v: bool) -> Result<Self::Ok>

Serialize a bool value.

fn serialize_char(self, v: char) -> Result<Self::Ok>

Serialize an char value.

fn serialize_int8(self, v: i8) -> Result<Self::Ok>

Serialize an i8 value.

fn serialize_uint8(self, v: u8) -> Result<Self::Ok>

Serialize an u8 value.

fn serialize_int16(self, v: i16) -> Result<Self::Ok>

Serialize an i16 value.

fn serialize_uint16(self, v: u16) -> Result<Self::Ok>

Serialize an u16 value.

fn serialize_int32(self, v: i32) -> Result<Self::Ok>

Serialize an i32 value.

fn serialize_uint32(self, v: u32) -> Result<Self::Ok>

Serialize an u32 value.

fn serialize_int64(self, v: i64) -> Result<Self::Ok>

Serialize an u64 value.

fn serialize_uint64(self, v: u64) -> Result<Self::Ok>

Serialize an i64 value.

fn serialize_real(self, v: f32) -> Result<Self::Ok>

Serialize an f32 value.

fn serialize_vector4(self, v: &Vector4) -> Result<Self::Ok>

Serialize an Vector4 value.

fn serialize_quaternion(self, v: &Quaternion) -> Result<Self::Ok>

Serialize an Quaternion value.

fn serialize_matrix3(self, v: &Matrix3) -> Result<Self::Ok>

Serialize an Matrix3 value.

fn serialize_rotation(self, v: &Rotation) -> Result<Self::Ok>

Serialize an Rotation value.

fn serialize_qstransform(self, v: &QsTransform) -> Result<Self::Ok>

Serialize an QsTransform value.

fn serialize_matrix4(self, v: &Matrix4) -> Result<Self::Ok>

Serialize an Matrix4 value.

fn serialize_transform(self, v: &Transform) -> Result<Self::Ok>

Serialize an Transform value.

fn serialize_pointer(self, v: Pointer) -> Result<Self::Ok>

Serialize an Pointer value.

fn serialize_array(self, _len: Option<usize>) -> Result<Self::SerializeSeq>

Serialize an Array value.

fn serialize_cstring(self, v: &CString<'_>) -> Result<Self::Ok>

Serialize an CString value.

fn serialize_ulong(self, v: Ulong) -> Result<Self::Ok>

Serialize an ULong(pointer size(u32 or u64)) value.

fn serialize_enum_flags(self) -> Result<Self::SerializeFlags>

Serialize an enum or Flags value.

fn serialize_half(self, v: f16) -> Result<Self::Ok>

Serialize an Half(f16) value.

fn serialize_stringptr(self, v: &StringPtr<'_>) -> Result<Self::Ok>

Serialize an StringPtr value.