Struct ArrayAtomBody 

#[repr(C)]
pub struct ArrayAtomBody<H, T>
where
    H: ArrayAtomHeader,
    T: 'static + Sized + Copy,
{
    pub header: H,
    pub data: [T],
}

Abstract type for dynamically sized atom bodies.

Many dynamically sized atoms bodies have a lot of their behaviour and raw representation in common. Therefore, they are abstracted to this struct that contains a header and an array of sized items.

If you don’t want to have a header, you can use () instead.

Not all combinations of header and data items are atom bodies, but many methods rely on the combination being an atom body.

Fields

header: H

data: [T]

Implementations

impl<H, T> ArrayAtomBody<H, T>

where Self: AtomBody, H: ArrayAtomHeader, T: 'static + Sized + Copy,

pub unsafe fn __initialize_body<'a, W>( writer: &mut W, parameter: &H::InitializationParameter, urids: &mut CachedMap, ) -> Result<(), ()>

where W: WritingFrame<'a> + WritingFrameExt<'a, Self>,

Internal method to initialize the body.

It simply calls the initialization method of the header, the data array will be left empty.

pub fn __create_ref<'a>(raw_data: &'a [u8]) -> Result<&'a Self, ()>

Internal method to create an atom body reference.

pub unsafe fn push<'a, W>(writer: &mut W, value: T) -> Result<(), ()>

where W: WritingFrame<'a> + WritingFrameExt<'a, Self>,

Push another value to the data array.

In case of insufficient memory, an Err is returned.

This method assumes that the atom was already initialized, but since can’t be checked, this method is unsafe.

pub unsafe fn append<'a, W>(writer: &mut W, slice: &[T]) -> Result<(), ()>

where W: WritingFrame<'a> + WritingFrameExt<'a, Self>,

Append a T slice to the data.

In case of insufficient memory, an Err is returned.

This method assumes that the atom was already initialized, but since can’t be checked, this method is unsafe.

impl ArrayAtomBody<LiteralHeader, u8>

pub fn as_str(&self) -> Result<&str, Utf8Error>

Try to parse the literal data as a &str

Parsing errors are forwarded.

pub fn lang(&self) -> URID

Return the language of the literal.

impl ArrayAtomBody<ObjectHeader, u8>

pub fn iter<'a>( &'a self, ) -> impl Iterator<Item = (&'a PropertyHeader, &'a Atom)>

Create an iterator over all properties of the object.

This iterator is based on the ChunkIterator.

impl ArrayAtomBody<SequenceHeader, u8>

pub fn time_unit(&self, urids: &mut CachedMap) -> TimeUnit

pub fn iter<'a>( &'a self, urids: &mut CachedMap, ) -> impl Iterator<Item = (TimeStamp, &'a Atom)>

impl ArrayAtomBody<(), i8>

pub fn as_cstr(&self) -> Result<&CStr, FromBytesWithNulError>

Try to wrap the string into a CStr reference.

This function returns an error if the internal conversion fails.

impl ArrayAtomBody<(), u8>

pub fn iter(&self) -> impl Iterator<Item = &Atom>

Create an iterator over all properties of the object.

This iterator is based on the AtomIterator.

impl<T> ArrayAtomBody<VectorHeader, T>

where T: 'static + AtomBody + Sized + Copy,

pub fn child_body_size(&self) -> usize

Return the size of the child type, according to the vector’s body header.

pub fn child_body_type(&self) -> URID

Return the type of the child, according to the vector’s body header.

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

Return a slice containing all items in the vector.

No allocation is done; This method simply borrows the data of the vector.