Struct zerovec::varzerovec::owned::VarZeroVecOwned
source · pub struct VarZeroVecOwned<T: ?Sized, F = Index16> {
marker: PhantomData<(Box<T>, F)>,
entire_slice: Vec<u8>,
}
Expand description
A fully-owned VarZeroVec
. This type has no lifetime but has the same
internal buffer representation of VarZeroVec
, making it cheaply convertible to
VarZeroVec
and VarZeroSlice
.
The F
type parameter is a VarZeroVecFormat
(see its docs for more details), which can be used to select the
precise format of the backing buffer with various size and performance tradeoffs. It defaults to Index16
.
Fields§
§marker: PhantomData<(Box<T>, F)>
§entire_slice: Vec<u8>
Implementations§
source§impl<T: VarULE + ?Sized, F> VarZeroVecOwned<T, F>
impl<T: VarULE + ?Sized, F> VarZeroVecOwned<T, F>
source§impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecOwned<T, F>
impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecOwned<T, F>
sourcepub fn from_slice(slice: &VarZeroSlice<T, F>) -> Self
pub fn from_slice(slice: &VarZeroSlice<T, F>) -> Self
Construct a VarZeroVecOwned from a VarZeroSlice
by cloning the internal data
sourcepub fn try_from_elements<A>(elements: &[A]) -> Result<Self, &'static str>where
A: EncodeAsVarULE<T>,
pub fn try_from_elements<A>(elements: &[A]) -> Result<Self, &'static str>where
A: EncodeAsVarULE<T>,
Construct a VarZeroVecOwned from a list of elements
sourcepub fn as_slice(&self) -> &VarZeroSlice<T, F>
pub fn as_slice(&self) -> &VarZeroSlice<T, F>
Obtain this VarZeroVec
as a VarZeroSlice
sourcepub(crate) fn with_capacity(capacity: usize) -> Self
pub(crate) fn with_capacity(capacity: usize) -> Self
Try to allocate a buffer with enough capacity for capacity
elements. Since T
can take up an arbitrary size this will
just allocate enough space for 4-byte Ts
sourcepub(crate) fn reserve(&mut self, capacity: usize)
pub(crate) fn reserve(&mut self, capacity: usize)
Try to reserve space for capacity
elements. Since T
can take up an arbitrary size this will
just allocate enough space for 4-byte Ts
sourceunsafe fn element_position_unchecked(&self, idx: usize) -> usize
unsafe fn element_position_unchecked(&self, idx: usize) -> usize
Get the position of a specific element in the data segment.
If idx == self.len()
, it will return the size of the data segment (where a new element would go).
§Safety
idx <= self.len()
and self.as_encoded_bytes()
is well-formed.
sourceunsafe fn element_range_unchecked(&self, idx: usize) -> Range<usize>
unsafe fn element_range_unchecked(&self, idx: usize) -> Range<usize>
Get the range of a specific element in the data segment.
§Safety
idx < self.len()
and self.as_encoded_bytes()
is well-formed.
sourceunsafe fn set_len(&mut self, len: usize)
unsafe fn set_len(&mut self, len: usize)
Set the number of elements in the list without any checks.
§Safety
No safe functions may be called until self.as_encoded_bytes()
is well-formed.
fn index_range(index: usize) -> Range<usize>
sourceunsafe fn index_data(&self, index: usize) -> &F::RawBytes
unsafe fn index_data(&self, index: usize) -> &F::RawBytes
Return the raw bytes representing the given index
.
§Safety
The index must be valid, and self.as_encoded_bytes() must be well-formed
sourceunsafe fn index_data_mut(&mut self, index: usize) -> &mut F::RawBytes
unsafe fn index_data_mut(&mut self, index: usize) -> &mut F::RawBytes
Return the mutable slice representing the given index
.
§Safety
The index must be valid. self.as_encoded_bytes() must have allocated space for this index, but need not have its length appropriately set.
sourceunsafe fn shift_indices(&mut self, starting_index: usize, amount: i32)
unsafe fn shift_indices(&mut self, starting_index: usize, amount: i32)
Shift the indices starting with and after starting_index
by the provided amount
.
§Safety
Adding amount
to each index after starting_index
must not result in the slice from becoming malformed.
The length of the slice must be correctly set.
sourcepub fn as_varzerovec<'a>(&'a self) -> VarZeroVec<'a, T, F>
pub fn as_varzerovec<'a>(&'a self) -> VarZeroVec<'a, T, F>
Get this VarZeroVecOwned
as a borrowed VarZeroVec
If you wish to repeatedly call methods on this VarZeroVecOwned
,
it is more efficient to perform this conversion first
sourcepub fn into_bytes(self) -> Vec<u8>
pub fn into_bytes(self) -> Vec<u8>
Consume this vector and return the backing buffer
sourceunsafe fn shift(
&mut self,
index: usize,
new_size: usize,
shift_type: ShiftType,
) -> &mut [u8] ⓘ
unsafe fn shift( &mut self, index: usize, new_size: usize, shift_type: ShiftType, ) -> &mut [u8] ⓘ
Invalidate and resize the data at an index, optionally inserting or removing the index. Also updates affected indices and the length. Returns a slice to the new element data - it doesn’t contain uninitialized data but its value is indeterminate.
§Safety
index
must be a valid index, or, ifshift_type == ShiftType::Insert
,index == self.len()
is allowed.new_size
musn’t result in the data segment growing larger thanF::MAX_VALUE
.
sourcefn verify_integrity(&self) -> bool
fn verify_integrity(&self) -> bool
Checks the internal invariants of the vec to ensure safe code will not cause UB. Returns whether integrity was verified.
Note: an index is valid if it doesn’t point to data past the end of the slice and is less than or equal to all future indices. The length of the index segment is not part of each index.
sourcepub fn push<A: EncodeAsVarULE<T> + ?Sized>(&mut self, element: &A)
pub fn push<A: EncodeAsVarULE<T> + ?Sized>(&mut self, element: &A)
Insert an element at the end of this vector
Methods from Deref<Target = VarZeroSlice<T, F>>§
sourcepub(crate) fn as_components<'a>(&'a self) -> VarZeroVecComponents<'a, T, F>
pub(crate) fn as_components<'a>(&'a self) -> VarZeroVecComponents<'a, T, F>
Obtain a VarZeroVecComponents
borrowing from the internal buffer
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Get the number of elements in this slice
§Example
let strings = vec!["foo", "bar", "baz", "quux"];
let vec = VarZeroVec::<str>::from(&strings);
assert_eq!(vec.len(), 4);
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if the slice contains no elements.
§Examples
let strings: Vec<String> = vec![];
let vec = VarZeroVec::<str>::from(&strings);
assert!(vec.is_empty());
sourcepub fn iter<'b>(&'b self) -> impl Iterator<Item = &'b T>
pub fn iter<'b>(&'b self) -> impl Iterator<Item = &'b T>
Obtain an iterator over this slice’s elements
§Example
let strings = vec!["foo", "bar", "baz", "quux"];
let vec = VarZeroVec::<str>::from(&strings);
let mut iter_results: Vec<&str> = vec.iter().collect();
assert_eq!(iter_results[0], "foo");
assert_eq!(iter_results[1], "bar");
assert_eq!(iter_results[2], "baz");
assert_eq!(iter_results[3], "quux");
sourcepub fn get(&self, idx: usize) -> Option<&T>
pub fn get(&self, idx: usize) -> Option<&T>
Get one of this slice’s elements, returning None
if the index is out of bounds
§Example
let strings = vec!["foo", "bar", "baz", "quux"];
let vec = VarZeroVec::<str>::from(&strings);
let mut iter_results: Vec<&str> = vec.iter().collect();
assert_eq!(vec.get(0), Some("foo"));
assert_eq!(vec.get(1), Some("bar"));
assert_eq!(vec.get(2), Some("baz"));
assert_eq!(vec.get(3), Some("quux"));
assert_eq!(vec.get(4), None);
sourcepub unsafe fn get_unchecked(&self, idx: usize) -> &T
pub unsafe fn get_unchecked(&self, idx: usize) -> &T
Get one of this slice’s elements
§Safety
index
must be in range
§Example
let strings = vec!["foo", "bar", "baz", "quux"];
let vec = VarZeroVec::<str>::from(&strings);
let mut iter_results: Vec<&str> = vec.iter().collect();
unsafe {
assert_eq!(vec.get_unchecked(0), "foo");
assert_eq!(vec.get_unchecked(1), "bar");
assert_eq!(vec.get_unchecked(2), "baz");
assert_eq!(vec.get_unchecked(3), "quux");
}
sourcepub fn as_bytes(&self) -> &[u8] ⓘ
pub fn as_bytes(&self) -> &[u8] ⓘ
Get a reference to the entire encoded backing buffer of this slice
The bytes can be passed back to Self::parse_byte_slice()
.
To take the bytes as a vector, see VarZeroVec::into_bytes()
.
§Example
let strings = vec!["foo", "bar", "baz"];
let vzv = VarZeroVec::<str>::from(&strings);
assert_eq!(vzv, VarZeroVec::parse_byte_slice(vzv.as_bytes()).unwrap());
sourcepub fn as_varzerovec<'a>(&'a self) -> VarZeroVec<'a, T, F>
pub fn as_varzerovec<'a>(&'a self) -> VarZeroVec<'a, T, F>
Get this VarZeroSlice
as a borrowed VarZeroVec
If you wish to repeatedly call methods on this VarZeroSlice
,
it is more efficient to perform this conversion first
sourcepub fn binary_search(&self, x: &T) -> Result<usize, usize>
pub fn binary_search(&self, x: &T) -> Result<usize, usize>
Binary searches a sorted VarZeroVec<T>
for the given element. For more information, see
the standard library function binary_search
.
§Example
let strings = vec!["a", "b", "f", "g"];
let vec = VarZeroVec::<str>::from(&strings);
assert_eq!(vec.binary_search("f"), Ok(2));
assert_eq!(vec.binary_search("e"), Err(2));
sourcepub fn binary_search_in_range(
&self,
x: &T,
range: Range<usize>,
) -> Option<Result<usize, usize>>
pub fn binary_search_in_range( &self, x: &T, range: Range<usize>, ) -> Option<Result<usize, usize>>
Binary searches a VarZeroVec<T>
for the given element within a certain sorted range.
If the range is out of bounds, returns None
. Otherwise, returns a Result
according
to the behavior of the standard library function binary_search
.
The index is returned relative to the start of the range.
§Example
let strings = vec!["a", "b", "f", "g", "m", "n", "q"];
let vec = VarZeroVec::<str>::from(&strings);
// Same behavior as binary_search when the range covers the whole slice:
assert_eq!(vec.binary_search_in_range("g", 0..7), Some(Ok(3)));
assert_eq!(vec.binary_search_in_range("h", 0..7), Some(Err(4)));
// Will not look outside of the range:
assert_eq!(vec.binary_search_in_range("g", 0..1), Some(Err(1)));
assert_eq!(vec.binary_search_in_range("g", 6..7), Some(Err(0)));
// Will return indices relative to the start of the range:
assert_eq!(vec.binary_search_in_range("g", 1..6), Some(Ok(2)));
assert_eq!(vec.binary_search_in_range("h", 1..6), Some(Err(3)));
// Will return `None` if the range is out of bounds:
assert_eq!(vec.binary_search_in_range("x", 100..200), None);
assert_eq!(vec.binary_search_in_range("x", 0..200), None);
sourcepub fn binary_search_by(
&self,
predicate: impl FnMut(&T) -> Ordering,
) -> Result<usize, usize>
pub fn binary_search_by( &self, predicate: impl FnMut(&T) -> Ordering, ) -> Result<usize, usize>
Binary searches a sorted VarZeroVec<T>
for the given predicate. For more information, see
the standard library function binary_search_by
.
§Example
let strings = vec!["a", "b", "f", "g"];
let vec = VarZeroVec::<str>::from(&strings);
assert_eq!(vec.binary_search_by(|probe| probe.cmp("f")), Ok(2));
assert_eq!(vec.binary_search_by(|probe| probe.cmp("e")), Err(2));
sourcepub fn binary_search_in_range_by(
&self,
predicate: impl FnMut(&T) -> Ordering,
range: Range<usize>,
) -> Option<Result<usize, usize>>
pub fn binary_search_in_range_by( &self, predicate: impl FnMut(&T) -> Ordering, range: Range<usize>, ) -> Option<Result<usize, usize>>
Binary searches a VarZeroVec<T>
for the given predicate within a certain sorted range.
If the range is out of bounds, returns None
. Otherwise, returns a Result
according
to the behavior of the standard library function binary_search
.
The index is returned relative to the start of the range.
§Example
let strings = vec!["a", "b", "f", "g", "m", "n", "q"];
let vec = VarZeroVec::<str>::from(&strings);
// Same behavior as binary_search when the range covers the whole slice:
assert_eq!(
vec.binary_search_in_range_by(|v| v.cmp("g"), 0..7),
Some(Ok(3))
);
assert_eq!(
vec.binary_search_in_range_by(|v| v.cmp("h"), 0..7),
Some(Err(4))
);
// Will not look outside of the range:
assert_eq!(
vec.binary_search_in_range_by(|v| v.cmp("g"), 0..1),
Some(Err(1))
);
assert_eq!(
vec.binary_search_in_range_by(|v| v.cmp("g"), 6..7),
Some(Err(0))
);
// Will return indices relative to the start of the range:
assert_eq!(
vec.binary_search_in_range_by(|v| v.cmp("g"), 1..6),
Some(Ok(2))
);
assert_eq!(
vec.binary_search_in_range_by(|v| v.cmp("h"), 1..6),
Some(Err(3))
);
// Will return `None` if the range is out of bounds:
assert_eq!(
vec.binary_search_in_range_by(|v| v.cmp("x"), 100..200),
None
);
assert_eq!(vec.binary_search_in_range_by(|v| v.cmp("x"), 0..200), None);