Enum VariableType

pub enum VariableType {
    Base(String),
    Bitfield(Bitfield, Box<VariableType>),
    Struct(String),
    Enum(String),
    Namespace,
    Pointer(Option<String>),
    Array {
        item_type_name: Box<VariableType>,
        count: usize,
    },
    Modified(Modifier, Box<VariableType>),
    Unknown,
    Other(String),
}

Available on crate feature debug only.

The variants of VariableType allows us to streamline the conditional logic that requires specific handling depending on the nature of the variable.

Variants

Base(String)

A variable with a Rust base datatype.

Bitfield(Bitfield, Box<VariableType>)

The variable is a range of bits in a wider (integer) type.

Struct(String)

A Rust struct.

Enum(String)

A Rust enum.

Namespace

Namespace refers to the path that qualifies a variable. e.g. “std::string” is the namespace for the struct “String”

Pointer(Option<String>)

A Pointer is a variable that contains a reference to another variable, and the type of the referenced variable may not be known until the reference has been resolved.

Array

A Rust array.

Fields

item_type_name: Box<VariableType>

The type name of the variable.

count: usize

The number of entries in the array.

Modified(Modifier, Box<VariableType>)

A type alias.

Unknown

When we are unable to determine the name of a variable.

Other(String)

For infrequently used categories of variables that does not fall into any of the other VariableType variants.

Implementations

impl VariableType

pub fn inner(&self) -> &Self

Get the inner type of a modified type.

pub fn is_phantom_data(&self) -> bool

Is this variable of a Rust PhantomData marker type?

pub fn is_array(&self) -> bool

Is this variable an array?

pub fn kind(&self) -> &str

Returns the string representation of the variable type’s kind.

Trait Implementations

impl Clone for VariableType

fn clone(&self) -> VariableType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VariableType

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

Formats the value using the given formatter.

impl Default for VariableType

fn default() -> VariableType

Returns the “default value” for a type.

impl PartialEq for VariableType

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for VariableType

impl StructuralPartialEq for VariableType