zerovec

https://docs.rs/zerovec/0.11.6/zerovec/
Admin
zerovec is a Rust library providing zero-copy vector abstractions for arbitrary types backed by byte...
Tokens:161,750
Snippets:994
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### ZeroVec Conversion Examples

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroVec.html

Examples demonstrating how to convert between different ZeroVec types and byte slices.

```APIDOC
## Convert a borrowed `ZeroVec`

### Description
Converts a borrowed `ZeroVec` into its byte representation.

### Method
`into_bytes()`

### Endpoint
N/A (Method on `ZeroVec`)

### Request Example
```rust
use zerovec::ZeroVec;

let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x01];
let zerovec: ZeroVec<u16> =
    ZeroVec::parse_bytes(bytes).expect("infallible");
let zv_bytes = zerovec.into_bytes();

assert!(!zv_bytes.is_owned());
assert_eq!(zv_bytes.get(0), Some(0xD3));
```

### Response Example
```rust
// No direct response, but zv_bytes will hold the byte representation.
```
```

```APIDOC
## Convert an owned `ZeroVec`

### Description
Converts an owned `ZeroVec` into its byte representation.

### Method
`into_bytes()`

### Endpoint
N/A (Method on `ZeroVec`)

### Request Example
```rust
use zerovec::ZeroVec;

let nums: &[u16] = &[211, 281, 421, 461];
let zerovec = ZeroVec::alloc_from_slice(nums);
let zv_bytes = zerovec.into_bytes();

assert!(zv_bytes.is_owned());
assert_eq!(zv_bytes.get(0), Some(0xD3));
```

### Response Example
```rust
// No direct response, but zv_bytes will hold the byte representation.
```
```

--------------------------------

### ZeroSlice Examples

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroSlice.html

Illustrative examples of using the ZeroSlice struct.

```APIDOC
## §Examples

Const-construct a `ZeroSlice` of u16:
```rust
use zerovec::ule::AsULE;
use zerovec::ZeroSlice;

const DATA: &ZeroSlice<u16> =
    ZeroSlice::<u16>::from_ule_slice(&<u16 as AsULE>::ULE::from_array([
        211, 281, 421, 32973,
    ]));

assert_eq!(DATA.get(1), Some(281));
```
```

--------------------------------

### ZeroMap Example Usage

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroMap.html

Demonstrates basic insertion and retrieval operations with ZeroMap.

```APIDOC
## Example Usage

### Description
This example shows how to create a `ZeroMap`, insert key-value pairs, and retrieve values using a probing function.

### Code
```rust
use zerovec::ZeroMap;

let mut map = ZeroMap::new();
map.insert(&1, &'a');
map.insert(&2, &'b');

// Retrieve a value using a closure for comparison
assert_eq!(map.get_copied_by(|probe| probe.cmp(&1)), Some('a'));

// Attempt to retrieve a non-existent value
assert_eq!(map.get_copied_by(|probe| probe.cmp(&3)), None);
```
```

--------------------------------

### Example Usage with Strings

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.VarZeroVec.html

Demonstrates how to use VarZeroVec with strings, including serialization and deserialization.

```APIDOC
## §Example

```rust
use zerovec::VarZeroVec;

// The little-endian bytes correspond to the list of strings.
let strings = vec!["w", "ω", "文", "𑄃"];

#[derive(serde::Serialize, serde::Deserialize)]
struct Data<'a> {
    #[serde(borrow)]
    strings: VarZeroVec<'a, str>,
}

let data = Data {
    strings: VarZeroVec::from(&strings),
};

let bincode_bytes =
    bincode::serialize(&data).expect("Serialization should be successful");

// Will deserialize without allocations
let deserialized: Data = bincode::deserialize(&bincode_bytes)
    .expect("Deserialization should be successful");

assert_eq!(deserialized.strings.get(2), Some("文"));
assert_eq!(deserialized.strings, &*strings);
```
```

--------------------------------

### Implement NicheBytes for NonZeroU8

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/trait.NicheBytes.html

Example implementation of NicheBytes for the NonZeroU8 type.

```Rust
impl NicheBytes<1> for NonZeroU8
Source
const NICHE_BIT_PATTERN: [u8; 1]
```

--------------------------------

### VarTuple and VarTupleULE Usage Example

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/vartuple/index.html

This example demonstrates how to use VarTuple and VarTupleULE to store and access employee data, combining a u32 ID with a string slice name.

```APIDOC
## Module vartuple
zerovec::ule

# Module vartuple Copy item path
Source
Search
Settings
Help

Summary
Expand description
Types to help compose fixed-size `ULE` and variable-size `VarULE` primitives.
This module exports `VarTuple` and `VarTupleULE`, which allow a single sized type and a single unsized type to be stored together as a `VarULE`.

## §Examples
```rust
use zerovec::ule::vartuple::{VarTuple, VarTupleULE};
use zerovec::VarZeroVec;

struct Employee<'a> {
    id: u32,
    name: &'a str,
};

let employees = [
    Employee {
        id: 12345,
        name: "Jane Doe",
    },
    Employee {
        id: 67890,
        name: "John Doe",
    },
];

let employees_as_var_tuples = employees
    .into_iter()
    .map(|x| VarTuple {
        sized: x.id,
        variable: x.name,
    })
    .collect::<Vec<_>>();

let employees_vzv: VarZeroVec<VarTupleULE<u32, str>> =
    employees_as_var_tuples.as_slice().into();

assert_eq!(employees_vzv.len(), 2);

assert_eq!(employees_vzv.get(0).unwrap().sized.as_unsigned_int(), 12345);
assert_eq!(&employees_vzv.get(0).unwrap().variable, "Jane Doe");

assert_eq!(employees_vzv.get(1).unwrap().sized.as_unsigned_int(), 67890);
assert_eq!(&employees_vzv.get(1).unwrap().variable, "John Doe");
```

## Structs§

VarTuple
    A sized type that can be converted to a `VarTupleULE`.

VarTupleULE
    A dynamically-sized type combining a sized and an unsized type.

```

--------------------------------

### CharULE Examples

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/struct.CharULE.html

Illustrates how to convert between char and CharULE, and how to handle invalid byte parsing.

```APIDOC
## §Examples

Convert a `char` to a `CharULE` and back again:
```rust
use zerovec::ule::{AsULE, CharULE, ULE};

let c1 = '𑄃';
let ule = c1.to_unaligned();
assert_eq!(CharULE::slice_as_bytes(&[ule]), &[0x03, 0x11, 0x01]);
let c2 = char::from_unaligned(ule);
assert_eq!(c1, c2);
```

Attempt to parse invalid bytes to a `CharULE`:
```rust
use zerovec::ule::{CharULE, ULE};

let bytes: &[u8] = &[0xFF, 0xFF, 0xFF, 0xFF];
CharULE::parse_bytes_to_slice(bytes).expect_err("Invalid bytes");
```
```

--------------------------------

### ZeroVec Creation and Usage Example

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroVec.html

Demonstrates how to create and use ZeroVec, including serialization and deserialization without allocations.

```APIDOC
## §Example

```rust
use zerovec::ZeroVec;

// The little-endian bytes correspond to the numbers on the following line.
let nums: &[u16] = &[211, 281, 421, 461];

#[derive(serde::Serialize, serde::Deserialize)]
struct Data<'a> {
    #[serde(borrow)]
    nums: ZeroVec<'a, u16>,
}

// The owned version will allocate
let data = Data {
    nums: ZeroVec::alloc_from_slice(nums),
};
let bincode_bytes = 
    bincode::serialize(&data).expect("Serialization should be successful");

// Will deserialize without allocations
let deserialized: Data = bincode::deserialize(&bincode_bytes)
    .expect("Deserialization should be successful");

// This deserializes without allocation!
assert!(!deserialized.nums.is_owned());
assert_eq!(deserialized.nums.get(2), Some(421));
assert_eq!(deserialized.nums, nums);
```
```

--------------------------------

### Implement VarULE and ZeroFrom

Source: https://docs.rs/zerovec/0.11.6/zerovec/attr.make_varule.html

Example demonstrating the use of make_varule alongside make_ule to create zero-copy data structures.

```rust
use std::borrow::Cow;
use zerofrom::ZeroFrom;
use zerovec::ule::encode_varule_to_box;
use zerovec::{VarZeroVec, ZeroMap, ZeroVec};

// custom fixed-size ULE type for ZeroVec
#[zerovec::make_ule(DateULE)]
#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)]
struct Date {
    y: u64,
    m: u8,
    d: u8,
}

// custom variable sized VarULE type for VarZeroVec
#[zerovec::make_varule(PersonULE)]
#[zerovec::derive(Serialize, Deserialize)]
#[derive(Clone, PartialEq, Eq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)]
struct Person<'a> {
    birthday: Date,
    favorite_character: char,
    #[serde(borrow)]
    name: Cow<'a, str>,
}

#[derive(serde::Serialize, serde::Deserialize)]
struct Data<'a> {
    // note: VarZeroVec always must reference the ULE type directly
    #[serde(borrow)]
    important_people: VarZeroVec<'a, PersonULE>,
}

let person1 = Person {
    birthday: Date {
        y: 1990,
        m: 9,
        d: 7,
    },
    favorite_character: 'π',
    name: Cow::from("Kate"),
};
let person2 = Person {
    birthday: Date {
        y: 1960,
        m: 5,
        d: 25,
    },
    favorite_character: '冇',
    name: Cow::from("Jesse"),
};

let important_people = VarZeroVec::from(&[person1, person2]);
let data = Data { important_people };

let bincode_bytes = bincode::serialize(&data).expect("Serialization should be successful");

// Will deserialize without allocations
let deserialized: Data =
    bincode::deserialize(&bincode_bytes).expect("Deserialization should be successful");

assert_eq!(&deserialized.important_people.get(1).unwrap().name, "Jesse");
assert_eq!(&deserialized.important_people.get(0).unwrap().name, "Kate");

// Since VarZeroVec produces PersonULE types, it's convenient to use ZeroFrom
// to recoup Person values in a zero-copy way
let person_converted: Person =
    ZeroFrom::zero_from(deserialized.important_people.get(1).unwrap());
assert_eq!(person_converted.name, "Jesse");
assert_eq!(person_converted.birthday.y, 1960);
```

--------------------------------

### Example Usage with ZeroSlice<u32>

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.VarZeroVec.html

Demonstrates using VarZeroVec with nested slices of integers (ZeroSlice<u32>).

```APIDOC
Here’s another example with `ZeroSlice<T>` (similar to `[T]`):

```rust
use zerovec::VarZeroVec;
use zerovec::ZeroSlice;

// The structured list correspond to the list of integers.
let numbers: &[&[u32]] = &[&[12, 25, 38], &[39179, 100], &[42, 55555], &[12345, 54321, 9]];

#[derive(serde::Serialize, serde::Deserialize)]
struct Data<'a> {
    #[serde(borrow)]
    vecs: VarZeroVec<'a, ZeroSlice<u32>>,
}

let data = Data {
    vecs: VarZeroVec::from(numbers),
};

let bincode_bytes =
    bincode::serialize(&data).expect("Serialization should be successful");

let deserialized: Data = bincode::deserialize(&bincode_bytes)
    .expect("Deserialization should be successful");

assert_eq!(deserialized.vecs[0].get(1).unwrap(), 25);
assert_eq!(deserialized.vecs[1], *numbers[1]);
```

`VarZeroVec`s can be nested infinitely via a similar mechanism, see the docs of `VarZeroSlice` for more information.
```

--------------------------------

### Create Empty VarZeroSlice

Source: https://docs.rs/zerovec/0.11.6/zerovec/vecs/type.VarZeroSlice32.html

Constructs a new, empty VarZeroSlice. No setup is required.

```rust
pub const fn new_empty() -> &'static Self
```

--------------------------------

### Example Usage of VarZeroVec

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/custom/index.html

Demonstrates the creation and usage of `VarZeroVec` with custom `Foo` structs. It initializes an array of `Foo` structs, converts it to a `VarZeroVec`, and then asserts the correctness of retrieved elements and their fields.

```rust
fn main() {
    let mut foos = [Foo {field1: 'u', field2: 983, field3: ZeroVec::alloc_from_slice(&[1212,2309,500,7000])},
                    Foo {field1: 'l', field2: 1010, field3: ZeroVec::alloc_from_slice(&[1932, 0, 8888, 91237])}];

    let vzv = VarZeroVec::<_>::from(&foos);

    assert_eq!(char::from_unaligned(vzv.get(0).unwrap().field1), 'u');
    assert_eq!(u32::from_unaligned(vzv.get(0).unwrap().field2), 983);
    assert_eq!(&vzv.get(0).unwrap().field3, &[1212,2309,500,7000][..]);

    assert_eq!(char::from_unaligned(vzv.get(1).unwrap().field1), 'l');
    assert_eq!(u32::from_unaligned(vzv.get(1).unwrap().field2), 1010);
    assert_eq!(&vzv.get(1).unwrap().field3, &[1932, 0, 8888, 91237][..]);
}
```

--------------------------------

### Create ZeroSlice with standard conversion functions

Source: https://docs.rs/zerovec/0.11.6/zerovec/macro.zeroslice.html

Examples of using the zeroslice macro with built-in AsULE conversion functions for common types.

```rust
use zerovec::{ZeroSlice, zeroslice, ule::AsULE};

const SIGNATURE: &ZeroSlice<char> = zeroslice!(char; <char as AsULE>::ULE::from_aligned; ['b', 'y', 'e', '✌']);
const EMPTY: &ZeroSlice<u32> = zeroslice![];

let empty: &ZeroSlice<u32> = zeroslice![];
let nums = zeroslice!(u32; <u32 as AsULE>::ULE::from_unsigned; [1, 2, 3, 4, 5]);
assert_eq!(nums.last().unwrap(), 5);
```

--------------------------------

### ZeroVec Serialization Example

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroVec.html

Demonstrates serializing and deserializing a struct containing a ZeroVec. Deserialization occurs without allocations, showcasing the zero-copy nature.

```rust
use zerovec::ZeroVec;

// The little-endian bytes correspond to the numbers on the following line.
let nums: &[u16] = &[211, 281, 421, 461];

#[derive(serde::Serialize, serde::Deserialize)]
struct Data<'a> {
    #[serde(borrow)]
    nums: ZeroVec<'a, u16>,
}

// The owned version will allocate
let data = Data {
    nums: ZeroVec::alloc_from_slice(nums),
};
let bincode_bytes =
    bincode::serialize(&data).expect("Serialization should be successful");

// Will deserialize without allocations
let deserialized: Data = bincode::deserialize(&bincode_bytes)
    .expect("Deserialization should be successful");

// This deserializes without allocation!
assert!(!deserialized.nums.is_owned());
assert_eq!(deserialized.nums.get(2), Some(421));
assert_eq!(deserialized.nums, nums);

```

--------------------------------

### Parse bytes into ZeroVec of NichedOption

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/union.NichedOptionULE.html

Example demonstrating how to parse a byte slice into a ZeroVec containing NichedOption values.

```rust
use core::num::NonZeroI8;
use zerovec::ule::NichedOption;
use zerovec::ZeroVec;

let bytes = &[0x00, 0x01, 0x02, 0x00];
let zv_no: ZeroVec<NichedOption<NonZeroI8, 1>> =
    ZeroVec::parse_bytes(bytes).expect("Unable to parse as NichedOption.");

assert_eq!(zv_no.get(0).map(|e| e.0), Some(None));
assert_eq!(zv_no.get(1).map(|e| e.0), Some(NonZeroI8::new(1)));
assert_eq!(zv_no.get(2).map(|e| e.0), Some(NonZeroI8::new(2)));
assert_eq!(zv_no.get(3).map(|e| e.0), Some(None));
```

--------------------------------

### ZeroMap Overview and Initialization

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroMap.html

This section covers the basic structure of ZeroMap and how to create new instances.

```APIDOC
## ZeroMap

A zero-copy map datastructure, built on sorted binary-searchable `ZeroVec` and `VarZeroVec`.

### Struct Definition
```rust
pub struct ZeroMap<'a, K, V>
where
    K: ZeroMapKV<'a> + ?Sized,
    V: ZeroMapKV<'a> + ?Sized,
{
    /* private fields */
}
```

### Examples
```rust
use zerovec::ZeroMap;

#[derive(serde::Serialize, serde::Deserialize)]
struct Data<'a> {
    #[serde(borrow)]
    map: ZeroMap<'a, u32, str>,
}

let mut map = ZeroMap::new();
map.insert(&1, "one");
map.insert(&2, "two");
map.insert(&4, "four");

let data = Data { map };

let bincode_bytes = bincode::serialize(&data).expect("Serialization should be successful");

// Will deserialize without any allocations
let deserialized: Data = bincode::deserialize(&bincode_bytes)
    .expect("Deserialization should be successful");

assert_eq!(data.map.get(&1), Some("one"));
assert_eq!(data.map.get(&2), Some("two"));
```

## Implementations

### impl<'a, K, V> ZeroMap<'a, K, V>

#### pub fn new() -> Self
Creates a new, empty `ZeroMap<K, V>`.

##### Examples
```rust
use zerovec::ZeroMap;

let zm: ZeroMap<u16, str> = ZeroMap::new();
assert!(zm.is_empty());
```

#### pub fn with_capacity(capacity: usize) -> Self
Construct a new `ZeroMap` with a given capacity.

#### pub fn as_borrowed(&'a self) -> ZeroMapBorrowed<'a, K, V>
Obtain a borrowed version of this map.

#### pub fn len(&self) -> usize
The number of elements in the `ZeroMap`.

#### pub fn is_empty(&self) -> bool
Whether the `ZeroMap` is empty.

#### pub fn clear(&mut self)
Remove all elements from the `ZeroMap`.

#### pub fn reserve(&mut self, additional: usize)
Reserve capacity for `additional` more elements to be inserted into the `ZeroMap` to avoid frequent reallocations.
See `Vec::reserve()` for more information.
```

--------------------------------

### Get element from ZeroSlice by index

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroSlice.html

Retrieves an element at a specific index from a ZeroSlice. Returns `None` if the index is out of bounds. The example demonstrates accessing an element and handling out-of-bounds access.

```rust
use zerovec::ZeroVec;

let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
let zerovec: ZeroVec<u16> =
    ZeroVec::parse_bytes(bytes).expect("infallible");

assert_eq!(zerovec.get(2), Some(421));
assert_eq!(zerovec.get(4), None);
```

--------------------------------

### Get ZeroSlice as bytes

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroSlice.html

Converts a ZeroVec into its underlying byte slice representation. This is useful for serialization purposes. The example shows the byte representation of a ZeroVec containing `u16` numbers.

```rust
use zerovec::ZeroVec;

// The little-endian bytes correspond to the numbers on the following line.
let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
let nums: &[u16] = &[211, 281, 421, 32973];

let zerovec = ZeroVec::alloc_from_slice(nums);

assert_eq!(bytes, zerovec.as_bytes());
```

--------------------------------

### Get ZeroSlice as an array

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroSlice.html

Attempts to retrieve the entire ZeroSlice as an array of a specified length `N`. Returns `None` if the slice does not contain exactly `N` elements. The example shows successful conversion and access to an array element.

```rust
use zerovec::ZeroVec;

let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
let zerovec: ZeroVec<u16> =
    ZeroVec::parse_bytes(bytes).expect("infallible");
let array: [u16; 4] =
    zerovec.get_as_array().expect("should be 4 items in array");

assert_eq!(array[2], 421);
```

--------------------------------

### ZeroMap Serialization and Deserialization Example

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroMap.html

Demonstrates how to use ZeroMap with bincode for serialization and deserialization. Ensure that types used in ZeroMap are compatible with ZeroVec or VarZeroVec, using fixed-size types for static data and dynamically sized types for variable data.

```rust
use zerovec::ZeroMap;

#[derive(serde::Serialize, serde::Deserialize)]
struct Data<'a> {
    #[serde(borrow)]
    map: ZeroMap<'a, u32, str>,
}

let mut map = ZeroMap::new();
map.insert(&1, "one");
map.insert(&2, "two");
map.insert(&4, "four");

let data = Data { map };

let bincode_bytes = 
    bincode::serialize(&data).expect("Serialization should be successful");

// Will deserialize without any allocations
let deserialized: Data = bincode::deserialize(&bincode_bytes)
    .expect("Deserialization should be successful");

assert_eq!(data.map.get(&1), Some("one"));
assert_eq!(data.map.get(&2), Some("two"));

```

--------------------------------

### GET /last

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroVec.html

Retrieves the last element of the slice.

```APIDOC
## GET /last

### Description
Gets the last element of the slice. Returns None if empty.

### Method
GET

### Response
#### Success Response (200)
- **element** (Option<T>) - The last element.
```

--------------------------------

### Initialize and Query a ZeroMap

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroMap.html

Demonstrates creating a new ZeroMap, inserting key-value pairs, and querying values using a comparator.

```rust
use zerovec::ZeroMap;

let mut map = ZeroMap::new();
map.insert(&1, &'a');
map.insert(&2, &'b');
assert_eq!(map.get_copied_by(|probe| probe.cmp(&1)), Some('a'));
assert_eq!(map.get_copied_by(|probe| probe.cmp(&3)), None);
```

--------------------------------

### GET /first

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroVec.html

Retrieves the first element of the slice.

```APIDOC
## GET /first

### Description
Gets the first element of the slice. Returns None if empty.

### Method
GET

### Response
#### Success Response (200)
- **element** (Option<T>) - The first element.
```

--------------------------------

### Any type_id

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/tuplevar/struct.Tuple5VarULE.html

Gets the `TypeId` of `self`. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### GET /get_subslice

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroVec.html

Retrieves a subslice of elements within a specified range.

```APIDOC
## GET /get_subslice

### Description
Gets a subslice of elements within a certain range. Returns None if the range is out of bounds.

### Method
GET

### Parameters
#### Query Parameters
- **range** (Range<usize>) - Required - The range of indices to retrieve.

### Response
#### Success Response (200)
- **subslice** (Option<&ZeroSlice<T>>) - The requested subslice.
```

--------------------------------

### GET /get_as_array

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroVec.html

Retrieves the entire slice as an array of a specific length.

```APIDOC
## GET /get_as_array

### Description
Gets the entire slice as an array of length N. Returns None if the slice does not have exactly N elements.

### Method
GET

### Parameters
#### Path Parameters
- **N** (usize) - Required - The length of the array to return.

### Response
#### Success Response (200)
- **array** (Option<[T; N]>) - The array of elements if the length matches.
```

--------------------------------

### Initialize and Query ZeroHashMap

Source: https://docs.rs/zerovec/0.11.6/zerovec/hashmap/struct.ZeroHashMap.html

Demonstrates creating a ZeroHashMap from an iterator and performing lookups for existing and non-existing keys.

```rust
use zerovec::ZeroHashMap;

let hashmap =
    ZeroHashMap::<i32, str>::from_iter([(0, "a"), (1, "b"), (2, "c")]);
assert_eq!(hashmap.get(&0), Some("a"));
assert_eq!(hashmap.get(&2), Some("c"));
assert_eq!(hashmap.get(&4), None);
```

--------------------------------

### From Implementations

Source: https://docs.rs/zerovec/0.11.6/zerovec/vecs/type.VarZeroVec16.html

Conversions into VarZeroVec from various types.

```APIDOC
### impl<A, T, F> From<&[A]> for VarZeroVec<'static, T, F>

#### Description
Converts to this type from the input type `&[A]`.
Available on `crate feature`alloc` only.

#### Method
`from`

#### Parameters
- **elements** (`&[A]`): The slice to convert from.

### impl<A, T, F, const N: usize> From<&[A; N]> for VarZeroVec<'static, T, F>

#### Description
Converts to this type from the input type `&[A; N]`.
Available on `crate feature`alloc` only.

#### Method
`from`

#### Parameters
- **elements** (`&[A; N]`): The array to convert from.

### impl<'a, T: ?Sized, F> From<&'a VarZeroSlice<T, F>> for VarZeroVec<'a, T, F>

#### Description
Converts to this type from the input type `&'a VarZeroSlice<T, F>`.

#### Method
`from`

#### Parameters
- **other** (`&'a VarZeroSlice<T, F>`): The `VarZeroSlice` to convert from.

### impl<A, T, F> From<&Vec<A>> for VarZeroVec<'static, T, F>

#### Description
Converts to this type from the input type `&Vec<A>`.
Available on `crate feature`alloc` only.

#### Method
`from`

#### Parameters
- **elements** (`&Vec<A>`): The vector to convert from.

### impl<'a, T: ?Sized, F> From<VarZeroVecOwned<T, F>> for VarZeroVec<'a, T, F>

#### Description
Converts to this type from the input type `VarZeroVecOwned<T, F>`.
Available on `crate feature`alloc` only.

#### Method
`from`

#### Parameters
- **other** (`VarZeroVecOwned<T, F>`): The owned `VarZeroVec` to convert from.
```

--------------------------------

### GET /get_copied

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroMap.html

Retrieves a direct copy of a value for fixed-size types.

```APIDOC
## GET /get_copied

### Description
For cases when `V` is fixed-size, obtain a direct copy of `V` instead of `V::ULE`.

### Method
GET

### Parameters
#### Query Parameters
- **key** (&K) - Required - The key to look up.

### Response
#### Success Response (200)
- **value** (Option<V>) - The copied value if the key exists.
```

--------------------------------

### CloneToUninit Implementation

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/struct.CharULE.html

Details the `clone_to_uninit` method for types implementing `CloneToUninit`.

```APIDOC
## impl<T> CloneToUninit for T
where T: Clone,

### Description
Provides a method to perform copy-assignment from `self` to an uninitialized memory location.

### Method
`unsafe fn clone_to_uninit(&self, dest: *mut u8)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
None

### Error Handling
None

### Notes
This is a nightly-only experimental API.
```

--------------------------------

### VarZeroVecOwned::as_bytes()

Source: https://docs.rs/zerovec/0.11.6/zerovec/vecs/struct.VarZeroVecOwned.html

Gets a reference to the entire encoded backing buffer of the VarZeroVecOwned.

```APIDOC
## pub fn as_bytes(&self) -> &[u8]

### Description
Get a reference to the entire encoded backing buffer of this slice
The bytes can be passed back to `Self::parse_bytes()`.
To take the bytes as a vector, see `VarZeroVec::into_bytes()`.

### Method
`as_bytes`

### Endpoint
N/A

### Example
```rust
let strings = vec!["foo", "bar", "baz"];
let vzv = VarZeroVec::<str>::from(&strings);

assert_eq!(vzv, VarZeroVec::parse_bytes(vzv.as_bytes()).unwrap());
```
```

--------------------------------

### Get subslice from ZeroVec

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroSlice.html

Demonstrates extracting a subslice from a ZeroVec using get_subslice.

```rust
use zerovec::ZeroVec;

let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
let zerovec: ZeroVec<u16> =
    ZeroVec::parse_bytes(bytes).expect("infallible");

assert_eq!(
    zerovec.get_subslice(1..3),
    Some(&*ZeroVec::from_slice_or_alloc(&[0x0119, 0x01A5]))
);
assert_eq!(zerovec.get_subslice(3..5), None);
```

--------------------------------

### Constructor: new()

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.VarZeroVec.html

Creates a new, empty VarZeroVec.

```APIDOC
### impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVec<'a, T, F>

#### pub const fn new() -> Self

Creates a new, empty `VarZeroVec<T>`.
```

--------------------------------

### Index32 Blanket Implementations

Source: https://docs.rs/zerovec/0.11.6/zerovec/vecs/struct.Index32.html

Details blanket implementations for Index32, such as Any, Borrow, BorrowMut, CloneToUninit, DynClone, From, Into, ToOwned, and TryFrom.

```APIDOC
## Blanket Implementations

### impl<T> Any for T
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T
#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T
#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> CloneToUninit for T
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.

### impl<T> DynClone for T
#### fn __clone_box(&self, _: Private) -> *mut ()

### impl<T> From<T> for T
#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T
#### fn into(self) -> U
Calls `U::from(self)`.

### impl<T> ToOwned for T
#### type Owned = T
#### fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning.

#### fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning.

### impl<T, U> TryFrom<U> for T
#### type Error = Infallible
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
```

--------------------------------

### ZeroMapKV Implementations

Source: https://docs.rs/zerovec/0.11.6/zerovec/maps/trait.ZeroMapKV.html

Demonstrates implementations of the ZeroMapKV trait for various primitive types and strings, showing their associated container, slice, GetType, and OwnedType.

```APIDOC
### impl<'a> ZeroMapKV<'a> for char

#### type Container = ZeroVec<'a, char>
#### type Slice = ZeroSlice<char>
#### type GetType = <char as AsULE>::ULE
#### type OwnedType = char

### impl<'a> ZeroMapKV<'a> for f32

#### type Container = ZeroVec<'a, f32>
#### type Slice = ZeroSlice<f32>
#### type GetType = <f32 as AsULE>::ULE
#### type OwnedType = f32

### impl<'a> ZeroMapKV<'a> for f64

#### type Container = ZeroVec<'a, f64>
#### type Slice = ZeroSlice<f64>
#### type GetType = <f64 as AsULE>::ULE
#### type OwnedType = f64

### impl<'a> ZeroMapKV<'a> for i8

#### type Container = ZeroVec<'a, i8>
#### type Slice = ZeroSlice<i8>
#### type GetType = <i8 as AsULE>::ULE
#### type OwnedType = i8

### impl<'a> ZeroMapKV<'a> for i16

#### type Container = ZeroVec<'a, i16>
#### type Slice = ZeroSlice<i16>
#### type GetType = <i16 as AsULE>::ULE
#### type OwnedType = i16

### impl<'a> ZeroMapKV<'a> for i32

#### type Container = ZeroVec<'a, i32>
#### type Slice = ZeroSlice<i32>
#### type GetType = <i32 as AsULE>::ULE
#### type OwnedType = i32

### impl<'a> ZeroMapKV<'a> for i64

#### type Container = ZeroVec<'a, i64>
#### type Slice = ZeroSlice<i64>
#### type GetType = <i64 as AsULE>::ULE
#### type OwnedType = i64

### impl<'a> ZeroMapKV<'a> for i128

#### type Container = ZeroVec<'a, i128>
#### type Slice = ZeroSlice<i128>
#### type GetType = <i128 as AsULE>::ULE
#### type OwnedType = i128

### impl<'a> ZeroMapKV<'a> for str

#### type Container = VarZeroVec<'a, str>
#### type Slice = VarZeroSlice<str>
#### type GetType = str
#### type OwnedType = Box<str>

### impl<'a> ZeroMapKV<'a> for u8

#### type Container = ZeroVec<'a, u8>
#### type Slice = ZeroSlice<u8>
#### type GetType = <u8 as AsULE>::ULE
#### type OwnedType = u8

### impl<'a> ZeroMapKV<'a> for u16

#### type Container = ZeroVec<'a, u16>
#### type Slice = ZeroSlice<u16>
#### type GetType = <u16 as AsULE>::ULE
#### type OwnedType = u16

### impl<'a> ZeroMapKV<'a> for u32

#### type Container = ZeroVec<'a, u32>
#### type Slice = ZeroSlice<u32>
#### type GetType = <u32 as AsULE>::ULE
#### type OwnedType = u32

### impl<'a> ZeroMapKV<'a> for u64

#### type Container = ZeroVec<'a, u64>
#### type Slice = ZeroSlice<u64>
#### type GetType = <u64 as AsULE>::ULE
#### type OwnedType = u64

### impl<'a> ZeroMapKV<'a> for u128

#### type Container = ZeroVec<'a, u128>
#### type Slice = ZeroSlice<u128>
#### type GetType = <u128 as AsULE>::ULE
#### type OwnedType = u128
```

--------------------------------

### VarZeroVecOwned::get_unchecked()

Source: https://docs.rs/zerovec/0.11.6/zerovec/vecs/struct.VarZeroVecOwned.html

Unsafely gets an element at a specific index. Panics if the index is out of bounds.

```APIDOC
## pub unsafe fn get_unchecked(&self, idx: usize) -> &T

### Description
Get one of this slice’s elements

### Safety
`index` must be in range

### Method
`get_unchecked`

### Endpoint
N/A

### Example
```rust
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");
}
```
```

--------------------------------

### VarZeroVecOwned::get()

Source: https://docs.rs/zerovec/0.11.6/zerovec/vecs/struct.VarZeroVecOwned.html

Safely gets an element at a specific index, returning None if out of bounds.

```APIDOC
## pub fn get(&self, idx: usize) -> Option<&T>

### Description
Get one of this slice’s elements, returning `None` if the index is out of bounds

### Method
`get`

### Endpoint
N/A

### Example
```rust
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);
```
```

--------------------------------

### Insert values into ZeroMap2d

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroMap2d.html

Shows how to insert key-value pairs and handle existing values.

```rust
use zerovec::ZeroMap2d;

let mut map = ZeroMap2d::new();
assert_eq!(map.insert(&0, "zero", "foo"), None,);
assert_eq!(map.insert(&1, "one", "bar"), None,);
assert_eq!(map.insert(&1, "one", "baz").as_deref(), Some("bar"),);
assert_eq!(map.get_2d(&1, "one"), Some("baz"));
assert_eq!(map.len(), 2);
```

--------------------------------

### VarZeroVecOwned::as_varzerovec()

Source: https://docs.rs/zerovec/0.11.6/zerovec/vecs/struct.VarZeroVecOwned.html

Gets a borrowed VarZeroVec from the VarZeroVecOwned. More efficient for repeated method calls.

```APIDOC
## pub fn as_varzerovec<'a>(&'a self) -> VarZeroVec<'a, T, F>

### Description
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

### Method
`as_varzerovec`

### Endpoint
N/A
```

--------------------------------

### From and Into Implementations

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/struct.CharULE.html

Details the `From<T>` for `T` and `Into<U>` for `T` trait implementations.

```APIDOC
## impl<T> From<T> for T

### Description
Allows creating an instance of `T` from another instance of `T`.

### Method
`fn from(t: T) -> T`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
None

### Error Handling
None

## impl<T, U> Into<U> for T
where U: From<T>,

### Description
Provides a conversion from `T` to `U` if `U` implements `From<T>`.

### Method
`fn into(self) -> U`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
None

### Error Handling
None
```

--------------------------------

### Getting Elements by Index

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.VarZeroSlice.html

Retrieves an element at a specific index, returning None if out of bounds.

```rust

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);
```

--------------------------------

### Get Length of VarZeroSlice

Source: https://docs.rs/zerovec/0.11.6/zerovec/vecs/type.VarZeroSlice32.html

Retrieves the number of elements in the slice. This method is safe to use directly.

```rust
pub fn len(&self) -> usize
```

--------------------------------

### OptionULE::new

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/struct.OptionULE.html

Constructs an OptionULE instance from an equivalent Option type.

```APIDOC
## fn new(opt: Option<U>) -> Self

### Description
Constructs an OptionULE<U> from an equivalent Option<T>.

### Parameters
- **opt** (Option<U>) - Required - The optional value to wrap in a ULE-compatible format.
```

--------------------------------

### Convert RawBytesULE to i128

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/struct.RawBytesULE.html

Gets the RawBytesULE as an i128. This is equivalent to calling AsULE::from_unaligned() on i128.

```rust
pub const fn as_signed_int(&self) -> i128
```

--------------------------------

### Convert RawBytesULE to u128

Source: https://docs.rs/zerovec/0.11.6/zerovec/ule/struct.RawBytesULE.html

Gets the RawBytesULE as a u128. This is equivalent to calling AsULE::from_unaligned() on u128.

```rust
pub const fn as_unsigned_int(&self) -> u128
```

--------------------------------

### Serialization

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.VarZeroSlice.html

Serialization capabilities for `VarZeroSlice` using the `serde` crate.

```APIDOC
## impl<T: VarULE + ?Sized + 'static, F: VarZeroVecFormat> Serialize for VarZeroSlice<T, F>

### Description
Serializes `VarZeroSlice` instances using the `serde` crate. Available when the `serde` Cargo feature is enabled.

### Method
`serialize`

### Parameters
- `serializer` (S) - The `serde` serializer.

### Response
#### Success Response (200)
- `Result<S::Ok, S::Error>` - The result of the serialization.
```

--------------------------------

### Get last element of ZeroVec

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.ZeroSlice.html

Retrieves the last element of the ZeroVec, returning None if empty.

```rust
use zerovec::ZeroVec;

let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
let zerovec: ZeroVec<u16> =
    ZeroVec::parse_bytes(bytes).expect("infallible");

assert_eq!(zerovec.last(), Some(32973));
```

--------------------------------

### How it Works

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.VarZeroVec.html

Explains the internal byte format used by VarZeroVec for serialization.

```APIDOC
## §How it Works

`VarZeroVec<T>`, when used with non-human-readable serializers (like `bincode`), will serialize to a specially formatted list of bytes. The format is:
  * 2 bytes for `length` (interpreted as a little-endian u16)
  * `2 * (length - 1)` bytes of `indices` (interpreted as little-endian u16s)
  * Remaining bytes for actual `data`

The format is tweakable by setting the `F` parameter, by default it uses u16 indices and lengths but other `VarZeroVecFormat` types can set other sizes.
Each element in the `indices` array points to the ending index of its corresponding data part in the `data` list. The starting index can be calculated from the ending index of the next element (or 0 for the first element). The last ending index, not stored in the array, is the length of the `data` segment.
See the design doc for more details.
```

--------------------------------

### VarZeroCow Methods

Source: https://docs.rs/zerovec/0.11.6/zerovec/struct.VarZeroCow.html

Methods for constructing and interacting with VarZeroCow instances.

```APIDOC
## Methods for VarZeroCow

### parse_bytes
- **Description**: Construct from a slice. Errors if the slice doesn’t represent a valid V.
- **Parameters**:
  - **bytes** (&'a [u8]) - Required - The byte slice to parse.

### parse_owned_bytes
- **Description**: Construct from an owned slice. Errors if the slice doesn’t represent a valid V. Requires 'alloc' feature.
- **Parameters**:
  - **bytes** (Box<[u8]>) - Required - The owned byte slice to parse.

### from_bytes_unchecked
- **Description**: Construct from a slice that is known to represent a valid V. Safety: bytes must be a valid V.
- **Parameters**:
  - **bytes** (&'a [u8]) - Required - The byte slice.

### from_encodeable
- **Description**: Construct this from an EncodeAsVarULE version of the contained type. Requires 'alloc' feature.
- **Parameters**:
  - **encodeable** (&E) - Required - The encodeable object.

### new_borrowed
- **Description**: Construct a new borrowed version of this.
- **Parameters**:
  - **val** (&'a V) - Required - The value to borrow.

### new_owned
- **Description**: Construct a new owned version of this. Requires 'alloc' feature.
- **Parameters**:
  - **val** (Box<V>) - Required - The value to own.

### is_owned
- **Description**: Returns true if the instance is owned.

### as_bytes
- **Description**: Get the byte representation of this type.
```
Tokens:
Raw