Enum Object 

pub enum Object<'a> {
    Offset(OffsetObject<'a>),
    VTable(VTableObject),
    Table(TableObject),
    Struct(StructObject),
    UnionTag(UnionTagObject),
    Union(UnionObject),
    UnionVectorTags(UnionVectorTagsObject),
    UnionVectorValues(UnionVectorValuesObject),
    Enum(EnumObject),
    Vector(VectorObject<'a>),
    Array(ArrayObject<'a>),
    Integer(IntegerObject),
    Float(FloatObject),
    Bool(BoolObject),
    String(StringObject),
    Unknown(ByteIndex),
}

Variants

Offset(OffsetObject<'a>)

4 bytes of offset inside a table

VTable(VTableObject)

0 actual bytes, all bytes are sub-objects of u16 types

Table(TableObject)

4 bytes of offset to a vtable. Fields are their own objects

Struct(StructObject)

0 bytes, actual bytes are in child objects

UnionTag(UnionTagObject)

1 byte of union tag

Union(UnionObject)

4 bytes of offset to the inner object

UnionVectorTags(UnionVectorTagsObject)

4 bytes of offset to the tags vector

UnionVectorValues(UnionVectorValuesObject)

4 bytes of offset to the values vector

Enum(EnumObject)

1, 2, 4 or 8 bytes of enum tag

Vector(VectorObject<'a>)

4 bytes length field. The actual elements are their own values

Array(ArrayObject<'a>)

0 bytes, actual elements are their own values

Integer(IntegerObject)

1, 2, 4 or 8 bytes of integer data

Float(FloatObject)

4 or 8 bytes of float data

Bool(BoolObject)

1 byte of bool data

String(StringObject)

4+n bytes of length and strings

Unknown(ByteIndex)

Unknown value

Implementations

impl Object<'_>

pub fn offset(&self) -> ByteIndex

pub fn have_braces(&self) -> bool

pub fn type_name(&self, declarations: &Declarations) -> Cow<'static, str>

Trait Implementations

impl Byterange for Object<'_>

fn byterange( &self, buffer: &InspectableFlatbuffer<'_>, ) -> (ByteIndex, ByteIndex)

impl<'a> Children<'a> for Object<'a>

fn children( &self, buffer: &InspectableFlatbuffer<'a>, callback: impl FnMut(Option<Cow<'a, str>>, Object<'a>), )

impl<'a> Clone for Object<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Object<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for Object<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> ObjectName<'a> for Object<'a>

fn print_object(&self, buffer: &InspectableFlatbuffer<'a>) -> String

impl<'a> PartialEq for Object<'a>

fn eq(&self, other: &Object<'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> Copy for Object<'a>

impl<'a> Eq for Object<'a>

impl<'a> StructuralPartialEq for Object<'a>