Struct AnonVec 

pub struct AnonVec { /* private fields */ }

An Anonymously typed Vector.

Internally, AnonVec is a Vec. When pushing to an AnonVec, T is converted to *const u8. When getting from an AnonVec, *const u8 is converted to T.

Usage

Anon Vec is intended for use in data systems where the type or size of the values stored cannot be known at compile-time. It is a more lax approach to Box<dyn Any>.

use anon_vec::AnonVec;
 
let mut anon = AnonVec::new::<i32>();
anon.push::<i32>(5);
anon.push::<i32>(10);
anon.push::<i32>(15);
 
let x = anon.get_ref::<i32>(1);

AnonVec can also work with Anon values.

use anon_vec::{AnonVec, Anon};
use std::mem::size_of;
use std::any::TypeId;
 
// Create AnonVec using the size and typeid.
let mut vec = AnonVec::from_size(size_of::<i32>(), TypeId::of::<i32>());
vec.push_anon(Anon::new::<i32>(5));
vec.push_anon(Anon::new::<i32>(10));
vec.push_anon(Anon::new::<i32>(15));
 
// move index 1 out and into `anon`.
let anon: Anon = vec.remove_get_anon(1);
 
let x: &i32 = anon.cast_ref::<i32>();

Implementations

impl AnonVec

pub fn new<T>() -> Self

where T: Any + 'static,

Creates a new Anonymously Typed Vector in-place.

Usage

use anon_vec::AnonVec;
 
let mut anon = AnonVec::new::<i32>();
anon.push::<i32>(5);

pub fn from_size(size: usize, typeid: TypeId) -> Self

Creates a new Anonymously Typed Vector using the size and TypeId of the value to be stored.

Usage

use anon_vec::AnonVec;
use std::mem::size_of;
use std::any::TypeId;
 
let mut anon = AnonVec::from_size(size_of::<i32>(), TypeId::of::<i32>());
anon.push::<i32>(5);

pub fn uninit() -> Self

Creates an Uninitialized Anonymously Typed Vector

MUST be initialized before access by calling init::. If you can’t call init::, call init_size instead.

Usage

use anon_vec::AnonVec;
 
let mut vec = AnonVec::uninit();
 
if vec.is_uninit() {
    vec.init::<i32>();
}
 
// do stuff with anon_vec

pub fn init<T>(&mut self)

where T: Any + 'static,

Initializes a previously uninitialized AnonVec.

Usage

use anon_vec::AnonVec;
 
let mut vec = AnonVec::uninit();
 
if vec.is_uninit() {
    vec.init::<i32>();
}
 
// do stuff with anon_vec

pub fn init_size(&mut self, size: usize, typeid: TypeId)

Initializes a previously uninitialized AnonVec.

Usage

use anon_vec::AnonVec;
use std::mem::size_of;
use std::any::TypeId;
 
let mut vec = AnonVec::uninit();
 
if vec.is_uninit() {
    vec.init_size(size_of::<i32>(), TypeId::of::<i32>());
}
 
// do stuff with anon_vec

pub fn typeid(&self) -> TypeId

The TypeId associated with this AnonVec.

pub fn size(&self) -> usize

The size, in bytes, each element of this AnonVec holds.

pub fn len(&self) -> usize

The number of elements this AnonVec holds. (as T)

pub fn is_empty(&self) -> bool

Whether or not this AnonVec has a length of 0.

pub fn is_uninit(&self) -> bool

Whether or not the size of this AnonVec is 0.

pub fn get_ref<T>(&self, index: usize) -> &T

where T: Any + 'static,

Get a reference to the interior value at index as T.

pub fn get_mut<T>(&mut self, index: usize) -> &mut T

where T: Any + 'static,

Get a mutable reference to the interior value at index as T.

pub fn reserve_bytes(&mut self, additional: usize)

Reserves additional number of BYTES. If you want to reserve size_of::, use reserve instead.

Reserves capacity for at least additional more elements to be inserted in the given Vec<T>. The collection may reserve more space to speculatively avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

Examples

let mut vec = vec![1];
vec.reserve(10);
assert!(vec.capacity() >= 11);

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the given Vec<T>. The collection may reserve more space to speculatively avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

Examples

let mut vec = vec![1];
vec.reserve(10);
assert!(vec.capacity() >= 11);

pub fn push<T>(&mut self, val: T)

where T: Any + 'static,

Appends an element to the back of this AnonVec.

pub fn push_anon(&mut self, anon: Anon)

Appends an anonymous element to the back of this AnonVec.

pub fn insert<T>(&mut self, val: T, index: usize)

Inserts an element at index, moving all elements after it to the right.

pub fn insert_anon(&mut self, anon: Anon, index: usize)

Inserts an anonymous element at index, moving all elements after it to the right.

pub fn remove(&mut self, index: usize)

Removes an element at index.

pub fn remove_get<T>(&mut self, index: usize) -> T

where T: Any + Clone + 'static,

Removes and returns the element at index.

pub fn remove_get_anon(&mut self, index: usize) -> Anon

Removes and returns the element at index as an anonymous type.

pub fn pop<T>(&mut self) -> Option<T>

where T: Any + Clone + 'static,

Pops off and returns the last element in the Vec.

pub fn pop_anon(&mut self) -> Option<Anon>

Pops off and returns the last element in the Vec as an Anon.

pub fn remove_swap(&mut self, index: usize)

Remove the last element after copying it into index. MUCH faster than remove, in certain situations.

pub fn iter<T>(&self) -> AnonIter<T>

Immutably Iterate over this AnonVec as T.

pub fn iter_mut<T>(&mut self) -> AnonIterMut<T>

Mutably Iterate over this AnonVec as T.