OCB3

https://docs.rs/ocb3
Admin
OCB3 is a pure Rust implementation of the Offset Codebook Mode v3 authenticated encryption with...
Tokens:186,246
Snippets:1,358
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Implementation for StreamCipherCoreWrapper

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

Example of implementing the KeyInit trait for the StreamCipherCoreWrapper type, demonstrating how to initialize it from a key.

```APIDOC
### impl<T> KeyInit for StreamCipherCoreWrapper<T>

#### fn new(key: &GenericArray<u8, <StreamCipherCoreWrapper<T> as KeySizeUser>::KeySize>) -> StreamCipherCoreWrapper<T>

Create new value from fixed size key.
```

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

### Slice len Method Example

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Demonstrates how to get the number of elements in a slice. This method is available on GenericArray due to Deref<Target = [T]>.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### StreamCipherCoreWrapper KeyInit Implementation

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

Example of implementing `KeyInit` for `StreamCipherCoreWrapper`. This implementation requires the inner type `T` to also implement `KeyInit` and specific block size constraints.

```rust
fn new( key: &GenericArray<u8, <StreamCipherCoreWrapper<T> as KeySizeUser>::KeySize>, ) -> StreamCipherCoreWrapper<T>
```

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

### Invalid Nonce Size Example (Ocb3)

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Demonstrates compilation failure when an invalid nonce size (e.g., 5 bytes) is used with Ocb3.

```rust
// Invalid nonce size equal to 5 bytes
let cipher = Ocb3::<Aes128, U5>::new(&key);
```

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

### Invalid Nonce Size Example (Ocb3)

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Demonstrates compilation failure when an invalid nonce size (e.g., 16 bytes) is used with Ocb3.

```rust
// Invalid nonce size equal to 16 bytes
let cipher = Ocb3::<Aes128, U16>::new(&key);
```

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

### Invalid Tag Size Example (Ocb3)

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Demonstrates compilation failure when an invalid tag size (e.g., 0 bytes) is used with Ocb3.

```rust
// Invalid tag size equal to 0 bytes
let cipher = Ocb3::<Aes128, U12, U0>::new(&key);
```

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

### Slice split_first Method Example

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Splits a slice into its first element and the rest of the elements, or None if the slice is empty. Available on GenericArray.

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

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

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

### Invalid Tag Size Example (Ocb3)

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Demonstrates compilation failure when an invalid tag size (e.g., 20 bytes) is used with Ocb3.

```rust
// Invalid tag size equal to 20 bytes
let cipher = Ocb3::<Aes128, U12, U20>::new(&key);
```

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

### Slice first Method Example

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Retrieves a reference to the first element of a slice, or None if the slice is empty. Available on GenericArray.

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

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

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

### KeyInit - new method

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

Use this method to create a new instance of a type using a key of a specific, fixed size. Ensure the provided key matches the expected `KeySize`.

```rust
fn new(key: &GenericArray<u8, Self::KeySize>) -> Self;
```

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

### Remove a prefix from a slice

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Use `strip_prefix` to get a subslice with the specified prefix removed. Returns `None` if the slice does not start with the prefix. Handles empty prefixes and prefixes equal to the slice.

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

```rust
let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

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

### KeyInit - new_from_slice method

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

Use this method to create a new instance from a byte slice, which can be of variable length. It returns a `Result` to handle potential `InvalidLength` errors.

```rust
fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength> { ... }
```

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

### Reverse split mutable subslices by predicate

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Use `rsplit_mut` to get an iterator over mutable subslices, starting from the end and working backwards. The matched element is not included. This allows in-place modification of subslices from the end.

```rust
let mut v = [100, 400, 300, 200, 600, 500];

let mut count = 0;
for group in v.rsplit_mut(|num| *num % 3 == 0) {
    count += 1;
    group[0] = count;
}
assert_eq!(v, [3, 400, 300, 2, 600, 1]);
```

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

### Implementation for Ocb3

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

Shows the implementation of the KeyInit trait for the Ocb3 cipher, which requires specific constraints on its generic parameters.

```APIDOC
### impl<Cipher, NonceSize, TagSize> KeyInit for Ocb3<Cipher, NonceSize, TagSize>

where Cipher: BlockSizeUser<BlockSize = U16> + BlockEncrypt + KeyInit + BlockDecrypt,
NonceSize: NonceSizes,
TagSize: TagSizes,
```

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

### Iterate Over Exact Slice Chunks (Reverse)

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Use `rchunks_exact` to get an iterator over chunks of exactly `chunk_size` elements, starting from the end. Elements not fitting into a full chunk are omitted. 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());

// The remainder can be retrieved using the `remainder` method on the iterator
assert_eq!(iter.remainder(), &['l']);
```

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

### Check if slice starts with a prefix

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Use `starts_with` to determine if a slice begins with a given sequence of elements. An empty slice is always considered a prefix.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

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

### KeyInit Trait Implementation

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Implements the KeyInit trait for Ocb3, providing methods for key initialization.

```APIDOC
### impl<Cipher, NonceSize, TagSize> KeyInit for Ocb3<Cipher, NonceSize, TagSize>

#### fn new(key: &Key<Self>) -> Self
Create new value from fixed size key.

#### fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength>
Create new value from variable size key.

#### fn generate_key( rng: impl CryptoRng + RngCore, ) -> GenericArray<u8, Self::KeySize>
Available on **crate feature`rand_core`** only.
Generate random key using the provided `CryptoRng`.
```

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

### Reverse split subslices by predicate

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Use `rsplit` to get an iterator over subslices, starting from the end of the slice and working backwards. The matched element is not included. Empty slices can be returned if the first or last elements match the predicate.

```rust
let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);
```

```rust
let v = &[0, 1, 1, 2, 3, 5, 8];
let mut it = v.rsplit(|n| *n % 2 == 0);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next().unwrap(), &[3, 5]);
assert_eq!(it.next().unwrap(), &[1, 1]);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next(), None);
```

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

### Iterate Over Slice Chunks (Reverse)

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Use `rchunks` to get an iterator over chunks of a specified size, starting from the end of the slice. The last chunk may be smaller if the slice length is not divisible by `chunk_size`. Panics if `chunk_size` is zero.

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

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

### Initialize Ocb3 with New Key

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Creates a new Ocb3 instance using a fixed-size key. This is part of the `KeyInit` trait implementation.

```rust
fn new(key: &Key<Self>) -> Self
```

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

### Iterate Over Mutable Slice Chunks (Reverse)

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Use `rchunks_mut` to get a mutable iterator over chunks of a specified size, starting from the end of the slice. The last chunk may be smaller if the slice length is not divisible by `chunk_size`. Panics if `chunk_size` is zero.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

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

### KeyInit - generate_key method

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

Available when the `rand_core` feature is enabled. Use this method to generate a cryptographically secure random key using a provided `CryptoRng`. This is useful for creating keys securely.

```rust
fn generate_key(
    rng: impl CryptoRng + RngCore,
) -> GenericArray<u8, Self::KeySize> { ... }
```

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

### Any type_id

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Gets the `TypeId` of `self`.

```APIDOC
## type_id

### Description
Gets the `TypeId` of `self`.

### Returns
- TypeId - The `TypeId` of the object.
```

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

### Generic Implementation for Inner Types

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

A generic implementation of KeyInit for types that wrap an inner type which also implements KeyInit.

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

where T: InnerInit,
<T as InnerUser>::Inner: KeyInit,
```

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

### type_id Method

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Gets the TypeId of self.

```APIDOC
#### fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.
Read more
```

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

### strip_prefix

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns a subslice with the prefix removed. If the slice starts with the `prefix`, it returns the subslice after the prefix. If the `prefix` is empty, it returns the original slice. If the `prefix` is equal to the original slice, it returns an empty slice. Returns `None` if the slice does not start with the `prefix`.

```APIDOC
## pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>
where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

### Description
Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

### Parameters
#### Path Parameters
- **prefix** (&P) - Required - The prefix to remove from the slice.

### Response
#### Success Response (Option<&[T]>)
- `Some(subslice)` if the slice starts with the `prefix`.
- `None` if the slice does not start with the `prefix`.

### Examples
```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```
```

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

### Partitioning a slice by key

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Demonstrates partitioning a slice into two parts based on a key extracted from each element. The first part contains unique keys, and the second contains elements with duplicate keys.

```rust
#![feature(slice_partition_dedup)]

let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];

let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);

assert_eq!(dedup, [10, 20, 30, 20, 11]);
assert_eq!(duplicates, [21, 30, 13]);

```

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

### Initialize OCB3 Cipher with a Key

Source: https://docs.rs/ocb3/latest/src/ocb3/lib.rs.html

Implements the `KeyInit` trait for `Ocb3`. Use this to create a new OCB3 cipher instance initialized with a secret key.

```rust
impl<Cipher, NonceSize, TagSize> KeyInit for Ocb3<Cipher, NonceSize, TagSize>
where
    Cipher: BlockSizeUser<BlockSize = U16> + BlockEncrypt + KeyInit + BlockDecrypt,
    NonceSize: sealed::NonceSizes,
    TagSize: sealed::TagSizes,
{
    fn new(key: &aead::Key<Self>) -> Self {
        Cipher::new(key).into()
    }
}
```

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

### iter

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns an iterator over the slice, yielding elements from start to end.

```APIDOC
## pub fn iter(&self) -> Iter<'_, T>

### Description
Returns an iterator over the slice.
The iterator yields all items from start to end.

### Examples
```
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```
```

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

### UTerm::new()

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U0.html

Instantiates a singleton representing this unsigned integer.

```APIDOC
## UTerm::new()

### Description
Instantiates a singleton representing this unsigned integer.

### Method
```rust
pub fn new() -> UTerm
```
```

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

### Iterate over slice elements

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns an iterator that yields all items from the start to the end of the slice.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

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

### iter_mut

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns an iterator that allows modifying each value in the slice, yielding elements from start to end.

```APIDOC
## pub fn iter_mut(&mut self) -> IterMut<'_, T>

### Description
Returns an iterator that allows modifying each value.
The iterator yields all items from start to end.

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

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

### Initialize Ocb3 from Key Slice

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Creates a new Ocb3 instance from a byte slice representing the key. Returns a `Result` which may contain an `InvalidLength` error.

```rust
fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength>
```

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

### get

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns a reference to an element or subslice depending on the type of index. Returns `None` if the index is out of bounds.

```APIDOC
## get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>

### Description
Returns a reference to an element or subslice depending on the type of index. If given a position, returns a reference to the element at that position or `None` if out of bounds. If given a range, returns the subslice corresponding to that range, or `None` if out of bounds.

### Method
`get`

### Parameters
* `index`: `I` where `I: SliceIndex<[T]>` - The index or range to access.

### Response
* `Option<&<I as SliceIndex<[T]>>::Output>`: An optional reference to the element or subslice, or `None` if the index is out of bounds.
```

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

### CloneToUninit clone_to_uninit

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

```APIDOC
## clone_to_uninit

### Description
Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

### Safety
This function is unsafe as it involves raw pointer manipulation.

### Parameters
- `dest`: *mut u8 - A raw pointer to the destination memory location.
```

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

### Iterate and modify slice elements

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns an iterator that allows modifying each value in the slice 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]);
```

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

### as_array

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Attempts to get a reference to the underlying array if the requested size `N` matches the slice's length.

```APIDOC
## as_array

### Description
Gets a reference to the underlying array.

### Method Signature
`pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>`

### Type Parameters
- `N`: The expected size of the array.

### Returns
- `Some(&[T; N])` if `N` is equal to the length of the slice.
- `None` otherwise.

### Examples
```rust
let arr: GenericArray<u8, U3> = [1, 2, 3].into();
let slice = arr.as_slice();

let array_ref: Option<&[u8; 3]> = slice.as_array();
assert!(array_ref.is_some());

let wrong_size_ref: Option<&[u8; 2]> = slice.as_array();
assert!(wrong_size_ref.is_none());
```
```

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

### Generic KeyInit Implementation for Inner Types

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

A generic implementation of `KeyInit` for types `T` where the inner type `Inner` also implements `KeyInit`. This allows for nested initialization patterns.

```rust
impl<T> KeyInit for T
where T: InnerInit,
 <T as InnerUser>::Inner: KeyInit,
```

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

### rchunks_exact

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap.

```APIDOC
## rchunks_exact(chunk_size: usize)

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap.

### Method
`rchunks_exact`

### Parameters
- **chunk_size** (usize) - The desired size of each chunk.

### Return Value
An iterator over mutable slices, each of size `chunk_size`.

### Panics
Panics if `chunk_size` is zero.

### Examples
```rust
let slice = [1, 2, 3, 4, 5];
let mut iter = slice.rchunks_exact(2);

assert_eq!(iter.next(), Some(&[4, 5]));
assert_eq!(iter.next(), Some(&[2, 3]));
assert_eq!(iter.next(), None);

// The remainder can be retrieved using the `remainder` method on the iterator
assert_eq!(iter.remainder(), &[1]);
```
```

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

### Encrypt and Decrypt with Aes128Ocb3

Source: https://docs.rs/ocb3/latest/ocb3/index.html

Demonstrates how to generate a key and nonce, then encrypt and decrypt a message using the Aes128Ocb3 cipher. Ensure the necessary traits like AeadCore, KeyInit, and OsRng are in scope.

```rust
use aes::Aes128;
use ocb3::{
    aead::{Aead, AeadCore, KeyInit, OsRng, generic_array::GenericArray},
    consts::U12,
    Ocb3,
};

type Aes128Ocb3 = Ocb3<Aes128, U12>;

let key = Aes128::generate_key(&mut OsRng);
let cipher = Aes128Ocb3::new(&key);
let nonce = Aes128Ocb3::generate_nonce(&mut OsRng);
let ciphertext = cipher.encrypt(&nonce, b"plaintext message".as_ref()).unwrap();
let plaintext = cipher.decrypt(&nonce, ciphertext.as_ref()).unwrap();

assert_eq!(&plaintext, b"plaintext message");

```

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

### UInt::new()

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U16.html

Instantiates a singleton representing this unsigned integer. This is a common pattern for compile-time integer representations.

```APIDOC
## Implementations
### impl<U, B> UInt<U, B>
#### pub fn new() -> UInt<U, B>
Instantiates a singleton representing this unsigned integer.
```

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

### rchunks

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap.

```APIDOC
## rchunks(chunk_size: usize)

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap.

### Method
`rchunks`

### Parameters
- **chunk_size** (usize) - The desired size of each chunk.

### Return Value
An iterator over slices, each of size `chunk_size` (except possibly the last one).

### Panics
Panics if `chunk_size` is zero.

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

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

### Slice is_empty Method Example

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Checks if a slice is empty. This method is available on GenericArray due to Deref<Target = [T]>.

```rust
let a = [1, 2, 3];
assert!(!a.is_empty());

let b: &[i32] = &[];
assert!(b.is_empty());
```

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

### TryFrom try_from

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Performs the conversion.

```APIDOC
## try_from

### Description
Performs the conversion.

### Parameters
- `value`: U - The value to be converted.

### Returns
- Result<T, <T as TryFrom<U>>::Error> - The converted value or an error if the conversion fails.
```

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

### KeyInit Trait Definition

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

Defines the interface for types that can be initialized from a key. It includes a required `new` method and several provided methods like `new_from_slice` and `generate_key`.

```APIDOC
## Trait KeyInit

Types which can be initialized from key.

### Required Methods

#### fn new(key: &GenericArray<u8, Self::KeySize>) -> Self

Create new value from fixed size key.

### Provided Methods

#### fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength>

Create new value from variable size key.

#### fn generate_key(rng: impl CryptoRng + RngCore) -> GenericArray<u8, Self::KeySize>

Available on **crate feature`rand_core`** only.
Generate random key using the provided `CryptoRng`.
```

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

### GenericArray<T, N> as AsRef<[T; 29]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 29 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 29]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 29]`: A shared reference to a fixed-size array of 29 elements.
```

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

### KeyInit Trait Definition

Source: https://docs.rs/ocb3/latest/ocb3/trait.KeyInit.html

Defines the interface for types that can be initialized from a key. Includes methods for creating from fixed-size keys, variable-size slices, and generating random keys.

```rust
pub trait KeyInit: Sized + KeySizeUser {
    // Required method
    fn new(key: &GenericArray<u8, Self::KeySize>) -> Self;

    // Provided methods
    fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength> { ... }
    fn generate_key(
        rng: impl CryptoRng + RngCore,
    ) -> GenericArray<u8, Self::KeySize> { ... }
}
```

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

### GenericArray<T, N> as AsRef<[T; 28]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 28 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 28]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 28]`: A shared reference to a fixed-size array of 28 elements.
```

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

### UTerm Cmp Implementations

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U0.html

Details the comparison implementations for UTerm.

```APIDOC
## impl<U, B> Cmp<UInt<U, B>> for UTerm

### Description
Compares `UTerm` with `UInt<U, B>`.

### Associated Type
```rust
type Output = Less;
```

## impl Cmp for UTerm

### Description
Compares `UTerm` with itself, resulting in `Equal`.

### Associated Type
```rust
type Output = Equal;
```
```

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

### GenericArray<T, N> as AsRef<[T; 27]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 27 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 27]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 27]`: A shared reference to a fixed-size array of 27 elements.
```

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

### UInt Implementations for U15

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U15.html

Details the implementations of various traits for the UInt type, which U15 is an alias for, enabling operations like addition, bitwise AND, OR, and XOR.

```APIDOC
## Implementations for UInt<U, B>

### `impl<U, B> UInt<U, B>`

#### `pub fn new() -> UInt<U, B>`
Instantiates a singleton representing this unsigned integer.

### `impl<U, B> Add<B0> for UInt<U, B>`
`U + B0 = U`

#### `type Output = UInt<U, B>`
The resulting type after applying the `+` operator.

#### `fn add(self, _: B0) -> <UInt<U, B> as Add<B0>>::Output`
Performs the `+` operation.

### `impl<U> Add<B1> for UInt<U, B1>`
`UInt<U, B1> + B1 = UInt<U + B1, B0>`

#### `type Output = UInt<<U as Add<B1>>::Output, B0>`
The resulting type after applying the `+` operator.

#### `fn add(self, _: B1) -> <UInt<U, B1> as Add<B1>>::Output`
Performs the `+` operation.

### `impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B1>`
`UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>`

#### `type Output = UInt<<Ul as Add<Ur>>::Output, B1>`
The resulting type after applying the `+` operator.

#### `fn add(self, rhs: UInt<Ur, B0>) -> <UInt<Ul, B1> as Add<UInt<Ur, B0>>>::Output`
Performs the `+` operation.

### `impl<Ul, Ur> Add<UInt<Ur, B1>> for UInt<Ul, B1>`
`UInt<Ul, B1> + UInt<Ur, B1> = UInt<(Ul + Ur) + B1, B0>`

#### `type Output = UInt<<<Ul as Add<Ur>>::Output as Add<B1>>::Output, B0>`
The resulting type after applying the `+` operator.

#### `fn add(self, rhs: UInt<Ur, B1>) -> <UInt<Ul, B1> as Add<UInt<Ur, B1>>>::Output`
Performs the `+` operation.

### `impl<B, U> Add<UTerm> for UInt<U, B>`
`X | UTerm = X`

#### `type Output = UInt<U, B>`
The resulting type after applying the `+` operator.

#### `fn add(self, _: UTerm) -> <UInt<U, B> as Add<UTerm>>::Output`
Performs the `+` operation.

### `impl<T, N> ArrayLength<T> for UInt<N, B1>`

#### `type ArrayType`
Deprecated: please upgrade to generic-array 1.x
Associated type representing the array type for the number

### `impl<U, B> Binary for UInt<UInt<U, B>, B1>`

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`
Formats the value using the given formatter.

### `impl<Ul, Bl, Ur> BitAnd<Ur> for UInt<Ul, Bl>`
Anding unsigned integers. We use our `PrivateAnd` operator and then `Trim` the output.

#### `type Output = <<UInt<Ul, Bl> as PrivateAnd<Ur>>::Output as Trim>::Output`
The resulting type after applying the `&` operator.

#### `fn bitand(self, rhs: Ur) -> <UInt<Ul, Bl> as BitAnd<Ur>>::Output`
Performs the `&` operation.

### `impl<Ul, Ur> BitOr<UInt<Ur, B0>> for UInt<Ul, B1>`
`UInt<Ul, B1> | UInt<Ur, B0> = UInt<Ul | Ur, B1>`

#### `type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>`
The resulting type after applying the `|` operator.

#### `fn bitor( self, rhs: UInt<Ur, B0>, ) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B0>>>::Output`
Performs the `|` operation.

### `impl<Ul, Ur> BitOr<UInt<Ur, B1>> for UInt<Ul, B1>`
`UInt<Ul, B1> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`

#### `type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>`
The resulting type after applying the `|` operator.

#### `fn bitor( self, rhs: UInt<Ur, B1>, ) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B1>>>::Output`
Performs the `|` operation.

### `impl<B, U> BitOr<UTerm> for UInt<U, B>`
`X | UTerm = X`

#### `type Output = UInt<U, B>`
The resulting type after applying the `|` operator.

#### `fn bitor(self, _: UTerm) -> <UInt<U, B> as BitOr<UTerm>>::Output`
Performs the `|` operation.

### `impl<Ul, Bl, Ur> BitXor<Ur> for UInt<Ul, Bl>`
Xoring unsigned integers. We use our `PrivateXor` operator and then `Trim` the output.

#### `type Output = <<UInt<Ul, Bl> as PrivateXor<Ur>>::Output as Trim>::Output`
The resulting type after applying the `^` operator.

#### `fn bitxor(self, rhs: Ur) -> <UInt<Ul, Bl> as BitXor<Ur>>::Output`
Performs the `^` operation.
```

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

### GenericArray<T, N> as AsRef<[T; 26]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 26 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 26]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 26]`: A shared reference to a fixed-size array of 26 elements.
```

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

### starts_with

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Returns `true` if the `needle` slice is a prefix of the current slice or equal to the slice.

```APIDOC
## pub fn starts_with(&self, needle: &[T]) -> bool
where T: PartialEq,

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice.

### Parameters
#### Path Parameters
- **needle** (&[T]) - Required - The slice to check if it's a prefix.

### Response
#### Success Response (bool)
- `true` if `needle` is a prefix of the slice.
- `false` otherwise.

### Examples
```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

Always returns `true` if `needle` is an empty slice:
```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```
```

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

### GenericArray<T, N> as AsRef<[T; 256]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 256 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 256]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 256]`: A shared reference to a fixed-size array of 256 elements.
```

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

### GenericArray<T, N> as AsRef<[T; 25]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 25 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 25]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 25]`: A shared reference to a fixed-size array of 25 elements.
```

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

### GenericArray<T, N> as AsRef<[T; 24]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 24 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 24]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 24]`: A shared reference to a fixed-size array of 24 elements.
```

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

### Clone Implementation

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U15.html

Provides methods for cloning UInt values.

```APIDOC
## clone(&self) -> UInt<U, B>

### Description
Returns a duplicate of the value.

### Method
`clone`
```

```APIDOC
## clone_from(&mut self, source: &Self)

### Description
Performs copy-assignment from `source`.

### Method
`clone_from`
```

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

### GenericArray<T, N> as AsRef<[T; 23]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 23 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 23]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 23]`: A shared reference to a fixed-size array of 23 elements.
```

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

### Min Implementation

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U15.html

Defines the minimum operation for UInt types.

```APIDOC
## Min<Ur> for UInt<U, B>

### Type
`Output`: The type of the minimum of `Self` and `Rhs`.

### Method
`min`
```

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

### try_into Method

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Performs the conversion.

```APIDOC
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.
```

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

### GenericArray<T, N> as AsRef<[T; 22]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 22 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 22]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 22]`: A shared reference to a fixed-size array of 22 elements.
```

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

### ToInt<i64> for UInt<U, B>

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U6.html

Provides a constant `INT` and a method `to_int()` for converting UInt to i64.

```APIDOC
## ToInt<i64> for UInt<U, B>

### Constant
#### `INT`
`Self::I64`

### Method
#### `to_int() -> i64`
Method returning the concrete value for the type.
```

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

### GenericArray<T, N> as AsRef<[T; 21]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 21 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 21]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 21]`: A shared reference to a fixed-size array of 21 elements.
```

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

### GenericArray<T, N> as AsRef<[T; 200]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 200 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 200]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 200]`: A shared reference to a fixed-size array of 200 elements.
```

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

### UInt to u64 Conversion

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U15.html

Provides methods and constants for converting a UInt to a u64.

```APIDOC
## const INT: u64
The concrete value for the type. Can be used in `const` contexts.

## fn to_int() -> u64
Method returning the concrete value for the type.
```

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

### GenericArray<T, N> as AsRef<[T; 20]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 20 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 20]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 20]`: A shared reference to a fixed-size array of 20 elements.
```

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

### ToInt<i64> for UInt<U, B>

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U15.html

Converts UInt to i64.

```APIDOC
## ToInt<i64> for UInt<U, B>

### Description
Converts `UInt` to `i64`.

### Constant
`INT: i64 = Self::I64`

### Function Signature
`fn to_int() -> i64`
```

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

### GenericArray<T, N> as AsRef<[T; 2]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 2 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 2]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 2]`: A shared reference to a fixed-size array of 2 elements.
```

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

### GenericArray<T, N> as AsRef<[T; 19]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 19 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 19]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 19]`: A shared reference to a fixed-size array of 19 elements.
```

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

### GenericArray<T, N> as AsRef<[T; 18]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 18 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 18]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 18]`: A shared reference to a fixed-size array of 18 elements.
```

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

### ToInt<u64> for UInt<U, B>

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U6.html

Provides a constant `INT` and a method `to_int()` for converting UInt to u64.

```APIDOC
## ToInt<u64> for UInt<U, B>

### Constant
#### `INT`
`Self::U64`

### Method
#### `to_int() -> u64`
Method returning the concrete value for the type.
```

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

### Into into

Source: https://docs.rs/ocb3/latest/ocb3/struct.Ocb3.html

Calls `U::from(self)`.

```APIDOC
## into

### Description
Calls `U::from(self)`. This conversion is determined by the implementation of `From<T> for U`.

### Returns
- U - The converted value.
```

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

### GenericArray<T, N> as AsRef<[T; 17]>

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Provides a way to get a shared reference to a fixed-size array of 17 elements from a GenericArray.

```APIDOC
## fn as_ref(&self) -> &[T; 17]

### Description
Converts this type into a shared reference of the (usually inferred) input type.

### Method
`as_ref`

### Parameters
None

### Response
- `&[T; 17]`: A shared reference to a fixed-size array of 17 elements.
```

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

### Ordering (`Ord`)

Source: https://docs.rs/ocb3/latest/ocb3/consts/type.U16.html

Provides methods for comparing UInt values.

```APIDOC
## impl<U, B> Ord for UInt<U, B>

Provides methods for comparing UInt values.

### Methods
- `cmp(&self, other: &UInt<U, B>) -> Ordering`: Compares `self` and `other` and returns an `Ordering`.
- `max(self, other: Self) -> Self`: Returns the maximum of two values.
- `min(self, other: Self) -> Self`: Returns the minimum of two values.
- `clamp(self, min: Self, max: Self) -> Self`: Restricts a value to a specified interval.
```

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

### as_mut_array

Source: https://docs.rs/ocb3/latest/ocb3/struct.GenericArray.html

Attempts to get a mutable reference to the underlying array if the requested size `N` matches the slice's length.

```APIDOC
## as_mut_array

### Description
Gets a mutable reference to the slice’s underlying array.

### Method Signature
`pub fn as_mut_array<const N: usize>(&mut self) -> Option<&mut [T; N]>`

### Type Parameters
- `N`: The expected size of the array.

### Returns
- `Some(&mut [T; N])` if `N` is equal to the length of the slice.
- `None` otherwise.

### Examples
```rust
let mut arr: GenericArray<u8, U3> = [1, 2, 3].into();
let slice = arr.as_mut_slice();

let array_mut_ref: Option<&mut [u8; 3]> = slice.as_mut_array();
assert!(array_mut_ref.is_some());

let wrong_size_mut_ref: Option<&mut [u8; 2]> = slice.as_mut_array();
assert!(wrong_size_mut_ref.is_none());
```
```
Tokens:
Raw