Struct jit::Ty [] [src]

pub struct Ty(_);

An object that represents a native system type

Each &Ty represents a basic system type, be it a primitive, a struct, a union, a pointer, or a function signature. The library uses this information to lay out values in memory.

Types are not attached to a context so they are reference-counted by LibJIT, so internally they are represented as Rc<Ty>. This represents a reference to the inner Ty.


impl Ty

fn get_size(&self) -> usize

Get the size of this type in bytes.

fn get_alignment(&self) -> usize

Get the alignment of this type in bytes.

fn get_kind(&self) -> TypeKind

Get a value that indicates the kind of this type. This allows callers to quickly classify a type to determine how it should be handled further.

fn get_ref(&self) -> Option<&Ty>

Get the type that is referred to by this pointer type.

fn get_return(&self) -> Option<&Ty>

Get the type returned by this function type.

fn set_names(&mut self, names: &[&str])

Set the field or parameter names of this struct or union type.

use jit::*;
let f64_t = get::<f64>();
let mut ty = Type::new_struct(&mut [&f64_t, &f64_t]);
ty.set_names(&["x", "y"]);
assert_eq!(ty.get_field("x").unwrap().get_type(), &f64_t as &Ty);
assert_eq!(ty.get_field("y").unwrap().get_type(), &f64_t as &Ty);

fn fields(&self) -> Fields

Iterate over the type's fields

use jit::*;
let pos_t = get::<(f64, f64)>();
let f64_t = get::<f64>();
for field in pos_t.fields() {
    assert_eq!(field.get_type(), &f64_t as &Ty);

fn params(&self) -> Params

Iterate over the function signature's parameters

use jit::*;
let sig_t = get::<fn(i32, i32) -> i32>();
let i32_t = get::<i32>();
for param in sig_t.params() {
    assert_eq!(param, &i32_t as &Ty);

fn get_field(&self, name: &str) -> Option<Field>

Find the field/parameter index for a particular name.

fn is_primitive(&self) -> bool

Check if this is a primitive

use jit::*;
assert!(!get::<(i16, i16)>().is_primitive());

fn is_float(&self) -> bool

Check if this is a floating-point number

use jit::*;

fn is_int(&self) -> bool

Check if this is an integer

use jit::*;

fn is_struct(&self) -> bool

Check if this is a struct

use jit::*;
assert!(get::<(i16, i16)>().is_struct());

fn is_union(&self) -> bool

Check if this is a union

fn is_signature(&self) -> bool

Check if this is a signature

use jit::*;
assert!(get::<fn(i16) -> i16>().is_signature());

fn is_pointer(&self) -> bool

Check if this is a pointer

use jit::*;
assert!(get::<&'static u8>().is_pointer());

fn is_tagged(&self) -> bool

Check if this is tagged

Trait Implementations

impl Debug for Ty

fn fmt(&self, fmt: &mut Formatter) -> Result

impl Eq for Ty

impl PartialEq for Ty

fn eq(&self, other: &Ty) -> bool

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

impl<'a> From<jit_type_t> for &'a Ty

fn from(ty: jit_type_t) -> &'a Ty

impl ToOwned for Ty

type Owned = Type

fn to_owned(&self) -> Type

impl<'a> Into<CowType<'a>> for &'a Ty

fn into(self) -> CowType<'a>

impl<'a> IntoIterator for &'a Ty

type IntoIter = Fields<'a>

type Item = Field<'a>

fn into_iter(self) -> Fields<'a>