rkyv

https://docs.rs/rkyv/latest/
Admin
rkyv is a zero-copy deserialization framework for Rust that enables fast serialization and...
Tokens:1,547,880
Snippets:8,001
Trust Score:9.7
Update:20 hours ago
Show doc for...
Tokens:
Raw
### get example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use get to retrieve an element or subslice by index or range, returning None if out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

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

### Basic binary_search example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use binary_search on a slice to find an element or get the insertion index. The example uses a sorted array and asserts the results for found and not-found values.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

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

### get example

Source: https://docs.rs/rkyv/latest/rkyv/string/struct.ArchivedString.html

Returns a subslice of str safely. The example shows valid and invalid ranges, including non-UTF-8 boundaries and out-of-bounds.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### Example: Serialize and deserialize with to_bytes

Source: https://docs.rs/rkyv/latest/rkyv/fn.to_bytes.html

A complete example showing how to use `to_bytes` to serialize an `Example` struct and then deserialize it with `from_bytes`. The example derives `Archive`, `Serialize`, and `Deserialize` traits and asserts equality after round-trip.

```rust
use rkyv::{
    from_bytes, rancor::Error, to_bytes, Archive, Deserialize, Serialize,
};

#[derive(Archive, Serialize, Deserialize, Debug, PartialEq)]
struct Example {
    name: String,
    value: i32,
}

let value = Example {
    name: "pi".to_string(),
    value: 31415926,
};

let bytes = to_bytes::<Error>(&value).unwrap();
let deserialized = from_bytes::<Example, Error>(&bytes).unwrap();

assert_eq!(deserialized, value);
```

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

### Example: Serialize and deserialize with from_bytes_unchecked

Source: https://docs.rs/rkyv/latest/rkyv/api/low/fn.from_bytes_unchecked.html

Complete example showing how to serialize a value with `to_bytes_in_with_alloc` and then deserialize it using `unsafe { from_bytes_unchecked::<Example, Failure>(&*bytes) }`. The example uses a custom `Example` struct with `Archive`, `Serialize`, and `Deserialize` derives, and asserts equality between the original and deserialized values.

```rust
use core::mem::MaybeUninit;

use rkyv::{
    access_unchecked,
    api::low::{from_bytes_unchecked, to_bytes_in_with_alloc},
    rancor::Failure,
    ser::{allocator::SubAllocator, writer::Buffer},
    util::Align,
    with::InlineAsBox,
    Archive, Deserialize, Serialize,
};

let mut output = Align([MaybeUninit::<u8>::uninit(); 256]);
let mut alloc = [MaybeUninit::<u8>::uninit(); 256];

#[derive(Archive, Serialize, Deserialize, Debug, PartialEq)]
struct Example {
    inner: i32,
}

let value = Example { inner: 42 };

let bytes = to_bytes_in_with_alloc::<_, _, Failure>(
    &value,
    Buffer::from(&mut *output),
    SubAllocator::new(&mut alloc),
)
.unwrap();

let deserialized =
    unsafe { from_bytes_unchecked::<Example, Failure>(&*bytes).unwrap() };
assert_eq!(value, deserialized);
```

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

### Separators at start or end

Source: https://docs.rs/rkyv/latest/rkyv/string/struct.ArchivedString.html

Example showing that separators at the start or end of a string are neighbored by empty strings.

```rust
let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);
```

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

### windows example: overlapping windows

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Demonstrates the windows method, which returns overlapping windows of a given size. Panics if size is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());
```

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

### Example: using NicheInto with Null and NaN

Source: https://docs.rs/rkyv/latest/rkyv/with/struct.NicheInto.html

Shows how to use NicheInto with Null and NaN niching to reduce the size of archived structs. The example defines BasicExample and NichedExample, then asserts that the archived size of NichedExample is smaller.

```rust
use core::mem::size_of;

use rkyv::{
    niche::niching::{NaN, Null},
    with::NicheInto,
    Archive, Archived,
};

#[derive(Archive)]
struct BasicExample {
    maybe_box: Option<Box<str>>,
    maybe_non_nan: Option<f32>,
}

#[derive(Archive)]
struct NichedExample {
    #[rkyv(with = NicheInto<Null>)]
    maybe_box: Option<Box<str>>,
    #[rkyv(with = NicheInto<NaN>)]
    maybe_non_nan: Option<f32>,
}

assert!(
    size_of::<Archived<BasicExample>>()
        > size_of::<Archived<NichedExample>>()
);
```

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

### Example: serialize and deserialize with rkyv low-level API

Source: https://docs.rs/rkyv/latest/rkyv/api/low/fn.deserialize.html

Complete example showing how to use `to_bytes_in_with_alloc` and `deserialize` from the low-level API. It defines a struct `Example`, serializes it to a buffer, then deserializes it back and asserts equality.

```rust
use core::mem::MaybeUninit;

use rkyv::{
    access_unchecked,
    api::low::{deserialize, to_bytes_in_with_alloc},
    rancor::Failure,
    ser::{allocator::SubAllocator, writer::Buffer},
    util::Align,
    with::InlineAsBox,
    Archive, Deserialize, Serialize,
};

let mut output = Align([MaybeUninit::<u8>::uninit(); 256]);
let mut alloc = [MaybeUninit::<u8>::uninit(); 256];

#[derive(Archive, Serialize, Deserialize, Debug, PartialEq)]
struct Example {
    inner: i32,
}

let value = Example { inner: 42 };

let bytes = to_bytes_in_with_alloc::<_, _, Failure>(
    &value,
    Buffer::from(&mut *output),
    SubAllocator::new(&mut alloc),
)
.unwrap();

let archived = unsafe { access_unchecked::<ArchivedExample>(&*bytes) };
let deserialized = deserialize::<Example, Failure>(archived).unwrap();
assert_eq!(value, deserialized);
```

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

### Example: mutably accessing archived data with access_pos_mut

Source: https://docs.rs/rkyv/latest/rkyv/api/high/fn.access_pos_mut.html

Shows how to use access_pos_mut to get mutable access to archived data and modify it. The example creates an archived Example, accesses it mutably, and changes the value field.

```rust
use rkyv::{
    api::{high::access_pos_mut, root_position},
    bytecheck::CheckBytes,
    rancor::Error, munge::munge,
    to_bytes, Archive, Archived, Serialize,
};

#[derive(Archive, Serialize)]
struct Example {
    name: String,
    value: i32,
}

let value = Example {
    name: "pi".to_string(),
    value: 31415926,
};

let mut bytes = to_bytes::<Error>(&value).unwrap();
let root_pos = root_position::<ArchivedExample>(bytes.len());

let mut archived =
    access_pos_mut::<ArchivedExample, Error>(&mut bytes, root_pos).unwrap();

// Because the access is mutable, we can mutate the archived data
munge!(let ArchivedExample { mut value, .. } = archived);
assert_eq!(*value, 31415926);
*value = 12345.into();
assert_eq!(*value, 12345);
```

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

### Example: Using AsBox with Archive derive

Source: https://docs.rs/rkyv/latest/rkyv/with/struct.AsBox.html

Shows how to use the AsBox wrapper with the Archive derive macro to serialize fields into boxes.

```rust
use rkyv::{with::AsBox, Archive};

#[derive(Archive)]
struct Example {
    #[rkyv(with = AsBox)]
    a: i32,
    #[rkyv(with = AsBox)]
    b: str,
}
```

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

### Example: using AtomicLoad with Relaxed ordering

Source: https://docs.rs/rkyv/latest/rkyv/with/struct.AtomicLoad.html

Example showing how to use AtomicLoad<Relaxed> to archive an AtomicU32 field in a derived Archive struct.

```rust
use core::sync::atomic::AtomicU32;

use rkyv::{
    with::{AtomicLoad, Relaxed},
    Archive,
};

#[derive(Archive)]
struct Example {
    #[rkyv(with = AtomicLoad<Relaxed>)]
    a: AtomicU32,
}
```

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

### match_indices example

Source: https://docs.rs/rkyv/latest/rkyv/string/struct.ArchivedString.html

Shows how to use match_indices to collect matches along with their starting indices. The third example demonstrates that overlapping matches only return the first occurrence.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

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

### trim_start basic usage example

Source: https://docs.rs/rkyv/latest/rkyv/string/struct.ArchivedString.html

Example showing how to use trim_start to remove only leading whitespace from a string slice.

```rust
let s = "\n Hello\tworld\t\n";
assert_eq!("Hello\tworld\t\n", s.trim_start());
```

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

### len example

Source: https://docs.rs/rkyv/latest/rkyv/util/struct.AlignedVec.html

Demonstrates getting the number of elements in an AlignedVec using len.

```rust
let mut a = AlignedVec::<16>::new();
a.extend_from_slice(&[1, 2, 3]);
assert_eq!(a.len(), 3);
```

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

### rchunks_exact example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Example usage of rchunks_exact on a slice, iterating from the end with exact chunk sizes and using remainder() to get leftover elements. Panics if chunk_size is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);
```

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

### Simple patterns for split

Source: https://docs.rs/rkyv/latest/rkyv/string/struct.ArchivedString.html

Examples of using split with char, string slice, and closure patterns, showing the resulting vectors.

```rust
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "AABBCC".split("DD").collect();
assert_eq!(v, ["AABBCC"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
```

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

### trim example

Source: https://docs.rs/rkyv/latest/rkyv/string/struct.ArchivedString.html

Example showing how to use trim to remove leading and trailing whitespace from a string slice.

```rust
let s = "\n Hello\tworld\t\n";

assert_eq!("Hello\tworld", s.trim());
```

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

### Example: mutating archived data with access_mut

Source: https://docs.rs/rkyv/latest/rkyv/api/high/fn.access_mut.html

Shows how to use access_mut to get mutable access to archived data and modify a field. The example defines a struct, serializes it, then mutates the archived value.

```rust
use rkyv::{
    access_mut,
    bytecheck::CheckBytes,
    rancor::Error, munge::munge,
    to_bytes, Archive, Archived, Serialize,
};

#[derive(Archive, Serialize)]
struct Example {
    name: String,
    value: i32,
}

let value = Example {
    name: "pi".to_string(),
    value: 31415926,
};

let mut bytes = to_bytes::<Error>(&value).unwrap();

let mut archived = access_mut::<ArchivedExample, Error>(&mut bytes)
    .unwrap();

// Because the access is mutable, we can mutate the archived data
munge!(let ArchivedExample { mut value, .. } = archived);
assert_eq!(*value, 31415926);
*value = 12345.into();
assert_eq!(*value, 12345);
```

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

### count_bytes: Example

Source: https://docs.rs/rkyv/latest/rkyv/ffi/struct.ArchivedCString.html

Shows how to use count_bytes to get the length of a C string without the nul terminator.

```rust
assert_eq!(c"foo".count_bytes(), 3);
assert_eq!(c"".count_bytes(), 0);
```

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

### Example: Using access_pos_with_context

Source: https://docs.rs/rkyv/latest/rkyv/api/fn.access_pos_with_context.html

A complete example that serializes a struct, then uses `access_pos_with_context` with a validator to safely access the archived data. It demonstrates the required imports, the `ArchivedExample` type, and the use of `root_position`.

```rust
use rkyv::{
    api::{access_pos_with_context, root_position},
    rancor::Error,
    to_bytes,
    validation::{
        archive::ArchiveValidator, shared::SharedValidator, Validator,
    },
    Archive, Deserialize, Serialize,
};

#[derive(Archive, Serialize, Deserialize)]
struct Example {
    name: String,
    value: i32,
}

let value = Example {
    name: "pi".to_string(),
    value: 31415926,
};

let bytes = to_bytes::<Error>(&value).unwrap();

let archived = access_pos_with_context::<ArchivedExample, _, Error>(
    &*bytes,
    root_position::<ArchivedExample>(bytes.len()),
    &mut Validator::new(
        ArchiveValidator::new(&*bytes),
        SharedValidator::new(),
    ),
)
.unwrap();

assert_eq!(archived.name.as_str(), "pi");
assert_eq!(archived.value.to_native(), 31415926);
```

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

### last example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use last to get the last element of a slice, returning None for empty slices.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

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

### resize example

Source: https://docs.rs/rkyv/latest/src/rkyv/util/alloc/aligned_vec.rs.html

Demonstrates the resize method, which changes the length of the vector, filling with a value when growing and truncating when shrinking. Two cases are shown: growing from length 1 to 3 with value 2, and shrinking from length 4 to 2.

```rust
# use rkyv::util::AlignedVec;

let mut vec = AlignedVec::<16>::new();
vec.push(3);
vec.resize(3, 2);
assert_eq!(vec.as_slice(), &[3, 2, 2]);

let mut vec = AlignedVec::<16>::new();
vec.extend_from_slice(&[1, 2, 3, 4]);
vec.resize(2, 0);
assert_eq!(vec.as_slice(), &[1, 2]);
```

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

### as_chunks example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Splits a slice into chunks of N elements from the start, returning a remainder. Panics if N is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (chunks, remainder) = slice.as_chunks();
assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
assert_eq!(remainder, &['m']);
```

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

### matches examples

Source: https://docs.rs/rkyv/latest/rkyv/string/struct.ArchivedString.html

Demonstrates using matches with a string pattern and with a closure to collect matching substrings.

```rust
let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);

let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
assert_eq!(v, ["1", "2", "3"]);
```

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

### split_last example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use split_last to get the last element and the rest of a slice. Returns None for empty slices.

```rust
let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}
```

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

### resize example

Source: https://docs.rs/rkyv/latest/rkyv/util/struct.AlignedVec.html

Demonstrates resizing an AlignedVec in-place, both extending with a fill value and truncating. Panics if new length exceeds MAX_CAPACITY.

```rust
let mut vec = AlignedVec::<16>::new();
vec.push(3);
vec.resize(3, 2);
assert_eq!(vec.as_slice(), &[3, 2, 2]);

let mut vec = AlignedVec::<16>::new();
vec.extend_from_slice(&[1, 2, 3, 4]);
vec.resize(2, 0);
assert_eq!(vec.as_slice(), &[1, 2]);
```

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

### split_first example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use split_first to get the first element and the rest of a slice. Returns None for empty slices.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}
```

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

### trim_ascii_start example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Demonstrates trimming leading ASCII whitespace from byte slices, including edge cases with only whitespace and empty slices.

```rust
assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");
```

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

### is_char_boundary() example

Source: https://docs.rs/rkyv/latest/rkyv/string/struct.ArchivedString.html

Checks whether a byte index is a valid UTF-8 code point boundary. The example shows that the start, end, and boundaries before multi-byte characters return true, while byte positions inside multi-byte characters return false.

```rust
let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));
```

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

### Using MapKV with HashMap and wrappers

Source: https://docs.rs/rkyv/latest/rkyv/with/struct.MapKV.html

Example showing how to apply MapKV to a HashMap field, using InlineAsBox for keys and Inline for values. Requires the rkyv crate and the with module.

```rust
use std::collections::HashMap;

use rkyv::{
    with::{Inline, InlineAsBox, MapKV},
    Archive,
};

#[derive(Archive)]
struct Example<'a> {
    // This will apply `InlineAsBox` to the `&str` key, and `Inline` to the
    // `&str` value.
    #[rkyv(with = MapKV<InlineAsBox, Inline>)]
    hash_map: HashMap<&'a str, &'a str>,
}
```

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

### last_mut example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use last_mut to get a mutable reference to the last element of a slice, returning None for empty slices.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

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

### grow_capacity_to example

Source: https://docs.rs/rkyv/latest/rkyv/util/struct.AlignedVec.html

Shows how to use the unsafe grow_capacity_to method to grow capacity to at least 50, which rounds up to 64. Requires new_cap greater than current capacity and panics if exceeding MAX_CAPACITY.

```rust
let mut vec = AlignedVec::<16>::new();
vec.push(1);
unsafe { vec.grow_capacity_to(50) };
assert_eq!(vec.len(), 1);
assert_eq!(vec.capacity(), 64);
```

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

### iter_mut example: modify each element

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use iter_mut to modify each element of a mutable slice. The iterator yields all items from start to end.

```rust
let x = &mut [1, 2, 4];
for elem in x.iter_mut() {
    *elem += 2;
}
assert_eq!(x, &[3, 4, 6]);
```

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

### Example: Using access_mut to mutate archived data

Source: https://docs.rs/rkyv/latest/rkyv/api/low/fn.access_mut.html

A complete example that serializes a struct to bytes, then uses `access_mut` to get a mutable reference to the archived data and modify a field. It demonstrates the required imports, the `munge!` macro for field access, and the assertion of the mutated value.

```rust
use core::mem::MaybeUninit;

use rkyv::{
    api::low::{to_bytes_in_with_alloc, access_mut},
    rancor::Failure,
    ser::{allocator::SubAllocator, writer::Buffer},
    util::Align,
    with::InlineAsBox,
    Archive, Serialize,
    munge::munge,
};

let mut output = Align([MaybeUninit::<u8>::uninit(); 256]);
let mut alloc = [MaybeUninit::<u8>::uninit(); 256];

#[derive(Archive, Serialize)]
struct Example {
    inner: i32,
}

let value = Example { inner: 42 };

let mut bytes = to_bytes_in_with_alloc::<_, _, Failure>(
    &value,
    Buffer::from(&mut *output),
    SubAllocator::new(&mut alloc),
)
.unwrap();

let mut archived = access_mut::<ArchivedExample, Failure>(
    &mut *bytes,
).unwrap();

// Because the access is mutable, we can mutate the archived data
munge!(let ArchivedExample { mut inner, .. } = archived);
assert_eq!(*inner, 42);
*inner = 12345.into();
assert_eq!(*inner, 12345);
```

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

### Example: Using AsOwned with Cow and Archive derive

Source: https://docs.rs/rkyv/latest/rkyv/with/struct.AsOwned.html

Shows how to use the AsOwned wrapper with the Archive derive macro to serialize a Cow as owned. Requires importing Cow, AsOwned, and Archive.

```rust
use std::borrow::Cow;

use rkyv::{with::AsOwned, Archive};

#[derive(Archive)]
struct Example<'a> {
    #[rkyv(with = AsOwned)]
    a: Cow<'a, str>,
}
```

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

### Example: implementing Niching for Option<u32>

Source: https://docs.rs/rkyv/latest/rkyv/niche/niching/trait.Niching.html

This example implements `Niching<ArchivedU32>` for a custom type `NeverOdd` to niche `Option<u32>` by using odd values. It demonstrates the required methods and shows that the archived representation is smaller than without niching.

```rust
use rkyv::{
    niche::niching::Niching, primitive::ArchivedU32, with::NicheInto,
    Archive, Archived, Place, Serialize,
};

// Let's niche `Option<u32>` by using odd values
struct NeverOdd;

impl Niching<ArchivedU32> for NeverOdd {
    unsafe fn is_niched(niched: *const ArchivedU32) -> bool {
        // Interprete odd values as "niched"
        unsafe { *niched % 2 == 1 }
    }

    fn resolve_niched(out: Place<ArchivedU32>) {
        // To niche, we use the value `1`
        out.write(ArchivedU32::from_native(1))
    }
}

#[derive(Archive)]
struct Basic {
    field: Option<u32>,
}

#[derive(Archive, Serialize)]
struct Niched {
    #[rkyv(with = NicheInto<NeverOdd>)]
    field: Option<u32>,
}

// Indeed, we have a smaller archived representation
assert!(size_of::<ArchivedNiched>() < size_of::<ArchivedBasic>());

let values: Vec<Niched> =
    (0..4).map(|n| Niched { field: Some(n) }).collect();

let bytes = rkyv::to_bytes(&values)?;
let archived = rkyv::access::<Archived<Vec<Niched>>, _>(&bytes)?;
assert_eq!(archived[0].field.as_ref(), Some(&0.into()));
assert_eq!(archived[1].field.as_ref(), None);
assert_eq!(archived[2].field.as_ref(), Some(&2.into()));
assert_eq!(archived[3].field.as_ref(), None);
```

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

### last_chunk_mut example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use last_chunk_mut to get a mutable array reference to the last N items. Returns None if slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_chunk_mut::<2>() {
    last[0] = 10;
    last[1] = 20;
}
assert_eq!(x, &[0, 10, 20]);

assert_eq!(None, x.last_chunk_mut::<4>());
```

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

### Example: Serialize, access, and deserialize with rkyv

Source: https://docs.rs/rkyv/latest/src/rkyv/api/low/mod.rs.html

This example shows how to use `to_bytes_in_with_alloc`, `access_unchecked`, and `deserialize` to round-trip a value. It requires the `Archive`, `Serialize`, `Deserialize` derives and uses a `Failure` error type. The example asserts that the deserialized value equals the original.

```rust
let mut output = Align([MaybeUninit::<u8>::uninit(); 256]);
let mut alloc = [MaybeUninit::<u8>::uninit(); 256];

#[derive(Archive, Serialize, Deserialize, Debug, PartialEq)]
struct Example {
    inner: i32,
}

let value = Example { inner: 42 };

let bytes = to_bytes_in_with_alloc::<_, _, Failure>(
    &value,
    Buffer::from(&mut *output),
    SubAllocator::new(&mut alloc),
)
.unwrap();

let archived = unsafe { access_unchecked::<ArchivedExample>(&*bytes) };
let deserialized = deserialize::<Example, Failure>(archived).unwrap();
assert_eq!(value, deserialized);
```

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

### last_chunk example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use last_chunk to get an array reference to the last N items. Returns None if slice is shorter than N, but returns Some(&[]) for N=0.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

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

### reserve_exact example

Source: https://docs.rs/rkyv/latest/src/rkyv/util/alloc/aligned_vec.rs.html

Shows how to reserve additional capacity in an AlignedVec with a specified alignment. The example creates a vector, pushes a value, reserves 10 more elements, and asserts the capacity is at least 11.

```rust
# use rkyv::util::AlignedVec;

let mut vec = AlignedVec::<16>::new();
vec.push(1);
vec.reserve_exact(10);
assert!(vec.capacity() >= 11);
```

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

### split_last_chunk_mut example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use split_last_chunk_mut to get a mutable reference to the last N items and the remaining slice. Returns None if slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk_mut::<2>() {
    last[0] = 3;
    last[1] = 4;
    elements[0] = 5;
}
assert_eq!(x, &[5, 3, 4]);

assert_eq!(None, x.split_last_chunk_mut::<4>());
```

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

### array_windows example

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Returns an iterator over overlapping windows of N elements starting at the beginning. If N is greater than the slice length, no windows are returned. Panics if N is zero.

```rust
let slice = [0, 1, 2, 3];
let mut iter = slice.array_windows();
assert_eq!(iter.next().unwrap(), &[0, 1]);
assert_eq!(iter.next().unwrap(), &[1, 2]);
assert_eq!(iter.next().unwrap(), &[2, 3]);
assert!(iter.next().is_none());
```

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

### sort_by example: ascending and reverse sorting

Source: https://docs.rs/rkyv/latest/rkyv/ser/writer/struct.Buffer.html

Shows how to use sort_by with a comparison function for ascending and reverse sorting. The first call sorts ascending, the second reverses the order. The example asserts the expected results.

```rust
let mut v = [4, -5, 1, -3, 2];
v.sort_by(|a, b| a.cmp(b));
assert_eq!(v, [-5, -3, 1, 2, 4]);

// reverse sorting
v.sort_by(|a, b| b.cmp(a));
assert_eq!(v, [4, 2, 1, -3, -5]);
```
Tokens:
Raw