Crate any_vec 

Type erased vector AnyVec. Allow to store elements of the same type. Have same performance and operations as std::vec::Vec.

You can downcast type erased AnyVec to concrete AnyVecTyped with downcast-family. Or use AnyVec type erased operations, which works with any_value.

    use any_vec::AnyVec;
    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);
    }

N.B. AnyVecTyped operations may be somewhat faster, due to the fact that compiler able to do better optimisation with full type knowledge.

Send, Sync, Clone

You can make AnyVec Sendable, Syncable, Cloneable:

 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:

 let v1: AnyVec<dyn Sync + Send> = AnyVec::new::<Rc<usize>>();

LazyClone

Whenever possible, any_vec types implement AnyValueCloneable, which can work with LazyClone:

 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

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.

AnyValue

Being type erased, AnyVec needs a way to operate on untyped values safely. Instead of working with plain *mut u8, AnyVec operates with any_value.

AnyValue is a trait, that provide operations to work with type erased values. Any type that implements AnyValue can be used with AnyVec. AnyValue interface allows to perform postponed operations on consumption. This trick used heavily by AnyVec destructive operations, which instead of concrete type return AnyValue, which perform actual operation on value drop.

Implementing AnyValueMut and AnyValueCloneable makes type mutable and cloneable respectively.

No alloc

This library is no_std and can work without alloc. For this - disable default alloc feature. mem::Heap will become unavailable after that, and you’ll have to specify MemBuilder for AnyVec. You can use mem::Stack, or specify your own Mem.

Modules

any_value

AnyValue is concept of type-erased object, that can be moved around without type knowledge.

element

mem

ops

AnyVec operations.

traits

Trait constraints. Possible variants Cloneable, Send and Sync, in any combination.

Structs

AnyVec

Type erased vec-like container. All elements have the same type.

AnyVecMut

Typed view to &mut AnyVec.

AnyVecRef

Typed view to &AnyVec.

AnyVecTyped

Concrete type AnyVec representation.

Iter

AnyVec iterator.

RawParts

AnyVec raw parts.

Traits

ElementIterator

SatisfyTraits

Trait for compile time check - does T satisfy Traits constraints.

Type Aliases

IterMut

Mutable reference AnyVec iterator. Return ElementMut items.

IterRef

Reference AnyVec iterator. Return ElementRef items.