Struct AstArray 

pub struct AstArray<T> {
    pub data: *mut T,
    pub size: usize,
}

Fields

data: *mut T

size: usize

Implementations

impl<T> AstArray<T>

pub fn begin(&self) -> *const T

impl<T> AstArray<T>

pub fn end(&self) -> *const T

impl<T> AstArray<T>

pub fn rbegin(&self) -> Rev<Iter<'_, T>>

impl<T> AstArray<T>

pub fn rend(&self) -> Rev<Iter<'_, T>>

impl<T> AstArray<T>

pub fn as_slice(&self) -> &[T]

The elements as a slice. C++ AstArray exposes begin()/end() over [data, data + size); the arena keeps the backing storage alive.

Safety note

data/size come from the arena allocator and are always a valid region (or data == null with size == 0), so this is sound for live nodes.

pub fn iter(&self) -> Iter<'_, T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl<T> Clone for AstArray<T>

where T: Clone,

fn clone(&self) -> AstArray<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for AstArray<T>

where T: Copy,

impl<T> Debug for AstArray<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for AstArray<T>

fn default() -> AstArray<T>

Returns the “default value” for a type.

impl<T> Eq for AstArray<T>

where T: Eq,

impl<T> Hash for AstArray<T>

where T: Hash,

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

where __H: Hasher,

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, T> IntoIterator for &'a AstArray<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a AstArray<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for AstArray<T>

where T: PartialEq,

fn eq(&self, other: &AstArray<T>) -> 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<T> StructuralPartialEq for AstArray<T>

where T: PartialEq,

impl<T: WriteJson> WriteJson for AstArray<T>

fn write_json(&self, enc: &mut AstJsonEncoder)

impl WriteJson for AstArray<c_char>

fn write_json(&self, enc: &mut AstJsonEncoder)