any_vec 0.15.0

Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

use core::any::TypeId;
use core::ptr::NonNull;
use crate::any_value::{AnyValue, AnyValueMut, AnyValueTypelessMut, AnyValueTypeless, AnyValueSizeless, AnyValueSizelessMut};
use crate::any_value::Unknown;

/// [AnyValueSizeless] non-owning byte ptr wrapper, that knows nothing about it's type.
/// 
/// Source should be forgotten, before pushing to [AnyVec].
/// Contained value **WILL NOT** be dropped on wrapper drop.
///
/// # Example
/// ```rust
/// # use std::any::TypeId;
/// # use std::mem;
/// # use std::mem::size_of;
/// # use std::ptr::NonNull;
/// # use any_vec::AnyVec;
/// # use any_vec::any_value::AnyValueSizelessRaw;
/// let s = String::from("Hello!");
/// let raw_value = unsafe{AnyValueSizelessRaw::new(
///     NonNull::from(&s).cast::<u8>()
/// )};
/// mem::forget(s);
///
/// let mut any_vec: AnyVec = AnyVec::new::<String>();
/// unsafe{
///     any_vec.push_unchecked(raw_value);
/// }
/// ```
///
/// [AnyVec]: crate::AnyVec
pub struct AnyValueSizelessRaw {
    ptr: NonNull<u8>
}

impl AnyValueSizelessRaw {
    #[inline]
    pub unsafe fn new(ptr: NonNull<u8>) -> Self{
        Self{ptr}
    }
}
impl AnyValueSizeless for AnyValueSizelessRaw {
    type Type = Unknown;

    #[inline]
    fn as_bytes_ptr(&self) -> *const u8 {
        self.ptr.as_ptr()
    }
}
impl AnyValueSizelessMut for AnyValueSizelessRaw {
    #[inline]
    fn as_bytes_mut_ptr(&mut self) -> *mut u8 {
        self.ptr.as_ptr()
    }
}

/// [AnyValueTypeless] byte ptr wrapper, that know it's type size.
/// 
/// Source should be forgotten, before pushing to [AnyVec].
/// Contained value **WILL NOT** be dropped on wrapper drop.
///
/// # Example
/// ```rust
/// # use std::any::TypeId;
/// # use std::mem;
/// # use std::mem::size_of;
/// # use std::ptr::NonNull;
/// # use any_vec::AnyVec;
/// # use any_vec::any_value::AnyValueTypelessRaw;
/// let s = String::from("Hello!");
/// let raw_value = unsafe{AnyValueTypelessRaw::new(
///     NonNull::from(&s).cast::<u8>(),
///     size_of::<String>()
/// )};
/// mem::forget(s);
///
/// let mut any_vec: AnyVec = AnyVec::new::<String>();
/// unsafe{
///     any_vec.push_unchecked(raw_value);
/// }
/// ```
///
/// [AnyVec]: crate::AnyVec
pub struct AnyValueTypelessRaw {
    ptr: NonNull<u8>,
    size: usize,
}

impl AnyValueTypelessRaw {
    #[inline]
    pub unsafe fn new(ptr: NonNull<u8>, size: usize) -> Self{
        Self{ptr, size}
    }
}

impl AnyValueSizeless for AnyValueTypelessRaw {
    type Type = Unknown;

    #[inline]
    fn as_bytes_ptr(&self) -> *const u8 {
        self.ptr.as_ptr()
    }
}
impl AnyValueSizelessMut for AnyValueTypelessRaw {
    #[inline]
    fn as_bytes_mut_ptr(&mut self) -> *mut u8 {
        self.ptr.as_ptr()
    }
}
impl AnyValueTypeless for AnyValueTypelessRaw {
    #[inline]
    fn size(&self) -> usize {
        self.size
    }
}
impl AnyValueTypelessMut for AnyValueTypelessRaw {}


/// [AnyValue] byte ptr wrapper, that know it's type.
/// 
/// Source should be forgotten, before pushing to [AnyVec].
/// Contained value **WILL NOT** be dropped on wrapper drop.
///
/// # Example
/// ```rust
/// # use std::any::TypeId;
/// # use std::mem;
/// # use std::mem::size_of;
/// # use std::ptr::NonNull;
/// # use any_vec::AnyVec;
/// # use any_vec::any_value::AnyValueRaw;
/// let s = String::from("Hello!");
/// let raw_value = unsafe{AnyValueRaw::new(
///     NonNull::from(&s).cast::<u8>(),
///     size_of::<String>(),
///     TypeId::of::<String>()
/// )};
/// mem::forget(s);
///
/// let mut any_vec: AnyVec = AnyVec::new::<String>();
/// unsafe{
///     any_vec.push_unchecked(raw_value);
/// }
/// ```
///
/// [AnyVec]: crate::AnyVec
pub struct AnyValueRaw {
    raw_unsafe: AnyValueTypelessRaw,
    typeid: TypeId
}

impl AnyValueRaw {
    #[inline]
    pub unsafe fn new(ptr: NonNull<u8>, size: usize, typeid: TypeId) -> Self{
        Self{
            raw_unsafe: AnyValueTypelessRaw::new(ptr, size),
            typeid
        }
    }
}

impl AnyValueSizeless for AnyValueRaw {
    type Type = Unknown;

    #[inline]
    fn as_bytes_ptr(&self) -> *const u8 {
        self.raw_unsafe.ptr.as_ptr()
    }
}
impl AnyValueSizelessMut   for AnyValueRaw {
    #[inline]
    fn as_bytes_mut_ptr(&mut self) -> *mut u8 {
        self.raw_unsafe.ptr.as_ptr()
    }
}
impl AnyValueTypeless for AnyValueRaw {
    #[inline]
    fn size(&self) -> usize {
        self.raw_unsafe.size
    }
}
impl AnyValue for AnyValueRaw {
    #[inline]
    fn value_typeid(&self) -> TypeId {
        self.typeid
    }
}

impl AnyValueTypelessMut for AnyValueRaw {}
impl AnyValueMut for AnyValueRaw {}