Union pr47::data::Value

#[repr(C)]
pub union Value {
    pub ptr: *mut dyn DynBase,
    pub ptr_repr: WidePointer,
    pub vt_data: ValueTypedData,
}

A generic stack value of Pr47. A stack value may be

• A value-typed data, see pr47::data::value_typed::ValueTypedData
• A normal reference to “heap” object, see pr47::data::wrapper::DynBase
• A custom pointer to container objects created in Pr47 VM, see pr47::data::wrapper::custom_vt::ContainerVT

A normal reference may be either owned, or shared/mutably shared from Rust. Check documentation of pr47::data::wrapper::Wrapper for more information. A custom pointer should never be shared from Rust, since it is only used when creating containers from Pr47 VM.

Pr47 uses tagged pointers to distinguish these three kinds of values:

+-----------------------------+
|         WidePointer         |
+--------------+--------------+
|      ptr     |  vtable/len  |
+-------|------+--------------+
        |
        |
+------------------------------+---+---+---+
|        PTR-BITS ... 3        | 2 | 1 | 0 |
+------------------------------+---+---+---+
| 8 byte aligned pointer value | U | C | V |
+------------------------------+---+---+---+

• U: Unused
• C: Container
• V: Value-typed

Since pr47::data::wrapper::Wrapper is 8 byte aligned, it is safe to use such a tagged-pointer

Fields

ptr: *mut dyn DynBase

ptr_repr: WidePointer

vt_data: ValueTypedData

Implementations

impl Value

pub fn new_owned<T>(data: T) -> Self where
    T: 'static,
    Void: StaticBase<T>, 

Create a new “owned” Value

pub fn new_container(
    wrapper: *mut Wrapper<()>,
    vt: *const GenericTypeVT
) -> Self

pub fn new_shared<T>(data: &T) -> Self where
    T: 'static,
    Void: StaticBase<T>, 

Create a new “shared” Value

pub fn new_mut_shared<T>(data: &mut T) -> Self where
    T: 'static,
    Void: StaticBase<T>, 

Create a new “mutably shared” Value

pub fn new_raw_value(tag: usize, repr: u64) -> Self

pub fn new_int(int_value: i64) -> Self

Create a new integer Value

pub fn new_float(float_value: f64) -> Self

Create a new floating point number Value

pub fn new_char(char_value: char) -> Self

Create a new character Value

pub fn new_bool(bool_value: bool) -> Self

Create a new boolean Value

pub const fn new_null() -> Self

Create a new null Value

pub fn is_null(&self) -> bool

Check if a Value is null.

pub fn is_value(&self) -> bool

Check if a Value is value-typed

pub fn is_ref(&self) -> bool

Check if a Value is reference-typed

pub fn is_container(&self) -> bool

Check if a Value is a custom pointer

pub unsafe fn untagged_ptr_field(&self) -> usize

Assuming that self may be a custom pointer, get the untagged pointer

pub unsafe fn ref_count(&self) -> u32

Assuming that self may be a custom pointer, get the reference counting

pub unsafe fn ref_count_norm(&self) -> u32

Given that self MUST NOT be a custom pointer, get the reference counting

pub unsafe fn incr_ref_count(&self)

Assuming that self may be a custom pointer, increase the reference counting

pub unsafe fn incr_ref_count_norm(&self)

Given that self MUST NOT be a custom pointer, increase the reference counting

pub unsafe fn decr_ref_count(&self)

Assuming that self may be a custom pointer, decrease the reference counting

pub unsafe fn decr_ref_count_norm(&self)

Given that self MUST NOT be a custom pointer, decrease the reference counting

pub unsafe fn ownership_info(&self) -> OwnershipInfo

Given that self MUST be a reference, assuming that self may be a custom pointer, get the ownership info

pub unsafe fn ownership_info_norm(&self) -> OwnershipInfo

Given that self MUST be a reference and MUST NOT be a custom pointer, get the ownership info

pub unsafe fn set_ownership_info(&self, ownership_info: OwnershipInfo)

Given that self MUST be a reference, assuming that self may be a custom pointer, set the ownership info

pub unsafe fn set_ownership_info_norm(&self, ownership_info: OwnershipInfo)

Given that self MUST be a reference and MUST NOT be a custom pointer, set the ownership info

pub unsafe fn gc_info(&self) -> u8

Given that self MUST be a reference, assuming that self may be a custom pointer, get the GC information

pub unsafe fn gc_info_norm(&self) -> u8

Given that self MUST be a reference and MUST NOT be a custom pointer, get the GC information

pub unsafe fn set_gc_info(&self, gc_info: u8)

Given that self MUST be a reference, assuming that self may be a custom pointer, set the GC information

pub unsafe fn set_gc_info_norm(&self, gc_info: u8)

Given that self MUST be a reference and MUST BOT be a custom pointer, set the GC information

pub unsafe fn get_as_dyn_base(&self) -> *mut dyn DynBase

pub unsafe fn get_as_mut_ptr<T>(&self) -> *mut T where
    T: 'static,
    Void: StaticBase<T>, 

Given that self MUST be a reference, assuming that self may be a custom pointer, get a pointer to the referenced data

pub unsafe fn get_as_mut_ptr_norm<T>(&self) -> *mut T where
    T: 'static,
    Void: StaticBase<T>, 

Given that self MUST be a reference and MUST NOT be a custom pointer, get a pointer to the referenced data

pub unsafe fn move_out<T>(&self) -> T where
    T: 'static,
    Void: StaticBase<T>, 

Given that self MUST be a reference to T typed VM-owned data, assuming that self may be a custom pointer, move the referenced data out

pub unsafe fn move_out_norm<T>(&self) -> T where
    T: 'static,
    Void: StaticBase<T>, 

Given that self MUST be a reference to T typed VM-owned data, and MUST NOT be a custom pointer, move out the referenced data out

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Value