Struct rustlr::generic_absyn::LBox

pub struct LBox<T: ?Sized> {
    pub exp: Box<T>,
    pub line: u32,
    pub column: u32,
    pub uid: u32,
}

Custom smart pointer that encapsulates line and column numbers along with a regular Box. Implements Deref and DerefMut so the encapsulated expression can be accessed as in a standard Box. This is intended to to be used in the formation of abstract syntax trees so that the lexical information is available for each construct after the parsing stage. Also included in each LBox created by the runtime parser (ZCParser) is a 32 bit (u32) unique identifier uid that uniquely identifies each LBox. An expression and a subexpression can both begin at the same line and column numbers and the unique id would be required to distinguish them. This device is useful for hashing information, such as inferred types, based on the location of an expression in the source.

Fields

exp: Box<T>

line: u32

column: u32

uid: u32

Implementations

impl<T> LBox<T>

pub fn new(e: T, ln: usize, col: usize) -> LBox<T>

creates a new LBox with line ln, column col and uid set to zero; this function is deprecated by LBox::make.

pub fn make(e: T, ln: usize, col: usize, u: u32) -> LBox<T>

creates a new LBox enclosing e, with line ln, column col and uid u

pub fn transfer<U>(&self, e: U) -> LBox<U>

should be used to create a new LBoxed expression that inherits lexical information from existing LBox

pub fn line(&self) -> usize

Since version 0.2.4, Rustlr now stores the line and column information internally as u32 values instead of usize, and the LBox::line and LBox::column functions are provided for interface

pub fn column(&self) -> usize

pub fn uid(&self) -> u32

impl<T: Default + ?Sized> LBox<T>

pub fn take(&mut self) -> T

replaces the boxed value with T::default() and returns the value

pub fn from_lc(c: LC<T>) -> Self

convert information from LC to LBox, consumes LC

impl<'t> LBox<dyn Any + 't>

pub fn downcast<U: 't>(self) -> Option<LBox<U>>

emulates Box::downcast function, when LBox<dyn Any> is used as the abstract syntax type. Note that unlike Box::downcast, an Option is returned here instead of a result.

pub fn upcast<T: 't>(lb: LBox<T>) -> Self

do not try to create a LBox<dyn Any> structure with something like

 let lb:LBox<dyn Any> = LBox::new(String::from("abc"),0,0);

This does not work as LBox is simply borrowing the underlying mechanics of Box instead of re-creating them. Do instead:

 let lb:LBox<dyn Any> = LBox::upcast(LBox::new(String::from("abc"),0,0));

upcast always returns a LBox<dyn Any>.

Trait Implementations

impl<T: ?Sized> AsMut<T> for LBox<T>

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: ?Sized> AsRef<T> for LBox<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for LBox<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for LBox<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for LBox<T>

fn default() -> Self

Returns the “default value” for a type.

impl Default for LBox<dyn Any>

this is provided so LBox<dyn Any> can be used for the abstract syntax type. the default is a Lbox containing a static string.

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for LBox<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for LBox<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.