Type erased vector. All elements have the same type.
Designed to be type-erased as far as possible - most operations do not know a concrete type. For example, you can move or copy/clone items from one type-erased vector to another, without ever knowing their type. Or you can erase, swap, move, copy elements inside type-erased vector, etc...
Only type-erased destruct and clone operations have additional overhead of indirect call.
let mut vec: AnyVec = AnyVec::new::<String>();
{
// Typed operations.
let mut vec = vec.downcast_mut::<String>().unwrap();
vec.push(String::from("0"));
vec.push(String::from("1"));
vec.push(String::from("2"));
}
let mut other_vec: AnyVec = AnyVec::new::<String>();
// Fully type erased element move from one vec to another
// without intermediate mem-copies.
let element = vec.swap_remove(0);
other_vec.push(element);
// Output 2 1
for s in vec.downcast_ref::<String>().unwrap(){
println!("{}", s);
}
See documentation for more.
You can make AnyVec
Send
able, Sync
able, Clone
able:
use any_vec::AnyVec;
use any_vec::traits::*;
let v1: AnyVec<dyn Cloneable + Sync + Send> = AnyVec::new::<String>();
let v2 = v1.clone();
This constraints will be applied compiletime to element type:
// This will fail to compile.
let v1: AnyVec<dyn Sync + Send> = AnyVec::new::<Rc<usize>>();
Non-Clonable AnyVec
has a size 1 pointer smaller.
Whenever possible, any_vec
type erased elements can be lazily cloned:
let mut v1: AnyVec<dyn Cloneable> = AnyVec::new::<String>();
v1.push(AnyValueWrapper::new(String::from("0")));
let mut v2: AnyVec<dyn Cloneable> = AnyVec::new::<String>();
let e = v1.swap_remove(0);
v2.push(e.lazy_clone());
v2.push(e.lazy_clone());
MemBuilder
+ Mem
works like Allocator
for AnyVec
. But unlike allocator,
Mem
container-specialized design allows to perform more optimizations. For example,
it is possible to make stack-allocated FixedAnyVec
and small-buffer-optimized(SBO) SmallAnyVec
from AnyVec
by just changing MemBuilder
:
type FixedAnyVec<Traits = dyn None> = AnyVec<Traits, Stack<512>>;
let mut any_vec: FixedAnyVec = AnyVec::new::<String>();
// This will be on stack, without any allocations.
any_vec.push(AnyValueWrapper::new(String::from("0")))
With help of clone_empty_in
you can use stack allocated, or SBO AnyVec
as fast intermediate storage for values of unknown type:
fn self_push_first_element<T: Trait + Cloneable>(any_vec: &mut AnyVec<T>){
let mut tmp = any_vec.clone_empty_in(StackN::<1, 256>);
tmp.push(any_vec.at(0).lazy_clone());
any_vec.push(tmp.pop().unwrap());
}
MemBuilder
interface, being stateful, allow to make Mem
, which can work with complex custom allocators.
This is no_std
library, which can work without alloc
too.
See CHANGELOG.md for version differences.
- type_erased_vec. Allow to store
Vec<T>
in type erased way, but you need to perform operations, you need to "cast" to concrete type first. - untyped_vec. Some operations like
len
,capacity
performed without type knowledge; but the rest - require concrete type.