Enum Unexpected

pub enum Unexpected<'a> {
    Void,
    Bool(bool),
    Char(char),
    Int8(i8),
    Uint8(u8),
    Int16(i16),
    Uint16(u16),
    Int32(i32),
    Uint32(u32),
    Int64(i64),
    Uint64(u64),
    Real(f32),
    Vector4(Vector4),
    Quaternion(Quaternion),
    Matrix3(Matrix3),
    Rotation(Rotation),
    QsTransform(QsTransform),
    Matrix4(Matrix4),
    Transform(Transform),
    Pointer(Pointer),
    Array,
    Enum,
    Struct,
    Variant(Variant),
    CString(CString<'a>),
    Ulong(Ulong),
    Flags,
    Half(f16),
    StringPtr(StringPtr<'a>),
    Other(&'a str),
}

Unexpected represents an unexpected invocation of any one of the Visitor trait methods.

This is used as an argument to the invalid_type, invalid_value, and invalid_length methods of the Error trait to build error messages.

Variants

Void

No type information.

• C++ type: void

Examples

This is often used to fill in generics elements with types for which generics are not used.

• hkArray<hkBool> -> vtype: TYPE_ARRAY, vsubtype: TYPE_BOOL
• hkBool -> vtype: TYPE_BOOL, vsubtype: TYPE_VOID
• There is also a pattern hkArray<void>. The type information is unknown, but this member always contains the SERIALIZE_IGNORED flag and can be skipped.

Bool(bool)

• C++ type: hkBool (bool)

Char(char)

• C++ type: hkChar (signed char)

Int8(i8)

• C++ type: hkInt8 (signed char)

Uint8(u8)

• C++ type: hkUint8 (unsigned char)

Int16(i16)

• C++ type: hkInt16 (signed short)

Uint16(u16)

• C++ type: hkUint16 (unsigned short)

Int32(i32)

• C++ type: hkInt32 (signed int)

Uint32(u32)

• C++ type: hkUint32 (unsigned int)

Int64(i64)

• C++ type: hkInt64 (signed long long)

Uint64(u64)

• C++ type: hkUint64 (unsigned long long)

Real(f32)

• C++ type: hkReal (float)

Vector4(Vector4)

• C++ type: hkVector4

Quaternion(Quaternion)

• C++ type: hkQuaternion

Matrix3(Matrix3)

• C++ type: hkMatrix3

Rotation(Rotation)

• C++ type: hkRotation

QsTransform(QsTransform)

• C++ type: hkQsTransform

Matrix4(Matrix4)

• C++ type: hkMatrix4

Transform(Transform)

• C++ type: hkTransform

Pointer(Pointer)

• C++ type: T*

Array

Array of items of type T.

• C++ type: hkArray<T>

Enum

enum type that stores only the size of SizeType in memory.

• C++ type: hkEnum<Enum,SizeType>

Struct

• C++ type: class | struct

Variant(Variant)

• C++ type: hkVariant (void* and hkClass*) type

CString(CString<'a>)

Null terminated string.

• C++ type: char*

Ulong(Ulong)

• C++ type: hkUlong (unsigned long), defined to always be the same size as a pointer

Flags

• C++ type: hkFlags<ENUM, SizeType> - 8,16,32 bits of named values.

Half(f16)

• C++ type: hkHalf (hkInt16), 16-bit float value

StringPtr(StringPtr<'a>)

Null-terminated string type.

There is a flag StringFlags::OWNED_FLAG = 0x1 defined in the class, so Owned is also possible.

It is unclear which segment (stack, heap, or other) is being pointed to because of the raw pointer.

• C++ type: hkStringPtr

Other(&'a str)

Other types

Trait Implementations

impl<'a> Clone for Unexpected<'a>

fn clone(&self) -> Unexpected<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Unexpected<'a>

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

Formats the value using the given formatter.

impl Display for Unexpected<'_>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Unexpected<'a>

fn eq(&self, other: &Unexpected<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for Unexpected<'a>