Enum FieldKind 

pub enum FieldKind {
    Bool(bool),
    U8(u8),
    I8(i8),
    U16(u16),
    I16(i16),
    U32(u32),
    I32(i32),
    U64(u64),
    I64(i64),
    F32(f32),
    F64(f64),
    UnitQuaternion(UnitQuaternion<f32>),
    Matrix4(Matrix4<f32>),
    BinaryBlob(Vec<u8>),
    Matrix3(Matrix3<f32>),
    Uuid(Uuid),
    UnitComplex(UnitComplex<f32>),
    PodArray {
        type_id: u8,
        element_size: u32,
        bytes: Vec<u8>,
    },
    Matrix2(Matrix2<f32>),
    Vector2F32(Vector2<f32>),
    Vector3F32(Vector3<f32>),
    Vector4F32(Vector4<f32>),
    Vector2F64(Vector2<f64>),
    Vector3F64(Vector3<f64>),
    Vector4F64(Vector4<f64>),
    Vector2U8(Vector2<u8>),
    Vector3U8(Vector3<u8>),
    Vector4U8(Vector4<u8>),
    Vector2I8(Vector2<i8>),
    Vector3I8(Vector3<i8>),
    Vector4I8(Vector4<i8>),
    Vector2U16(Vector2<u16>),
    Vector3U16(Vector3<u16>),
    Vector4U16(Vector4<u16>),
    Vector2I16(Vector2<i16>),
    Vector3I16(Vector3<i16>),
    Vector4I16(Vector4<i16>),
    Vector2U32(Vector2<u32>),
    Vector3U32(Vector3<u32>),
    Vector4U32(Vector4<u32>),
    Vector2I32(Vector2<i32>),
    Vector3I32(Vector3<i32>),
    Vector4I32(Vector4<i32>),
    Vector2U64(Vector2<u64>),
    Vector3U64(Vector3<u64>),
    Vector4U64(Vector4<u64>),
    Vector2I64(Vector2<i64>),
    Vector3I64(Vector3<i64>),
    Vector4I64(Vector4<i64>),
    String(String),
}

The internal data format of crate::visitor::Visitor. Fields are limited to being one of these types. This means that all crate::visitor::Visit values must be built from some assortment of these types. Fields can be accessed from a visitor using crate::visitor::Visit::visit on a variable with the same type as the field.

Variants

Bool(bool)

Boolean value.

U8(u8)

u8 value.

I8(i8)

i8 value.

U16(u16)

u16 value.

I16(i16)

i16 value.

U32(u32)

u32 value.

I32(i32)

i32 value.

U64(u64)

u64 value.

I64(i64)

i64 value.

F32(f32)

f32 value.

F64(f64)

f64 value.

UnitQuaternion(UnitQuaternion<f32>)

Unit quaternion.

Matrix4(Matrix4<f32>)

4x4 f32 matrix.

BinaryBlob(Vec<u8>)

A representation of some Vec<T> where T must be Copy. It is mostly used to store the bytes of string types.

Matrix3(Matrix3<f32>)

3x3 f32 matrix.

Uuid(Uuid)

Unique id.

UnitComplex(UnitComplex<f32>)

A complex number.

PodArray

A representation for arrays of crate::visitor::pod::Pod types as a Vec<u8>.

Fields

type_id: u8

A code to identify the Pod type of the elements of the array. Taken from crate::visitor::pod::Pod::type_id.

element_size: u32

The number of bytes in each array element.

bytes: Vec<u8>

The bytes that store the data, with unspecified endianness.

Matrix2(Matrix2<f32>)

2x2 f32 matrix.

Vector2F32(Vector2<f32>)

2D f32 vector.

Vector3F32(Vector3<f32>)

3D f32 vector.

Vector4F32(Vector4<f32>)

4D f32 vector.

Vector2F64(Vector2<f64>)

2D f64 vector.

Vector3F64(Vector3<f64>)

3D f64 vector.

Vector4F64(Vector4<f64>)

4D f64 vector.

Vector2U8(Vector2<u8>)

2D u8 vector.

Vector3U8(Vector3<u8>)

3D u8 vector.

Vector4U8(Vector4<u8>)

4D u8 vector.

Vector2I8(Vector2<i8>)

2D i8 vector.

Vector3I8(Vector3<i8>)

3D i8 vector.

Vector4I8(Vector4<i8>)

4D i8 vector.

Vector2U16(Vector2<u16>)

2D u16 vector.

Vector3U16(Vector3<u16>)

3D u16 vector.

Vector4U16(Vector4<u16>)

4D u16 vector.

Vector2I16(Vector2<i16>)

2D i16 vector.

Vector3I16(Vector3<i16>)

3D i16 vector.

Vector4I16(Vector4<i16>)

4D i16 vector.

Vector2U32(Vector2<u32>)

2D u32 vector.

Vector3U32(Vector3<u32>)

3D u32 vector.

Vector4U32(Vector4<u32>)

4D u32 vector.

Vector2I32(Vector2<i32>)

2D i32 vector.

Vector3I32(Vector3<i32>)

3D i32 vector.

Vector4I32(Vector4<i32>)

4D i32 vector.

Vector2U64(Vector2<u64>)

2D u64 vector.

Vector3U64(Vector3<u64>)

3D u64 vector.

Vector4U64(Vector4<u64>)

4D u64 vector.

Vector2I64(Vector2<i64>)

2D i64 vector.

Vector3I64(Vector3<i64>)

3D i64 vector.

Vector4I64(Vector4<i64>)

4D i64 vector.

String(String)

A unicode string.

Trait Implementations

impl Debug for FieldKind

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

Formats the value using the given formatter.

impl PartialEq for FieldKind

fn eq(&self, other: &FieldKind) -> 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 StructuralPartialEq for FieldKind