API Response

https://docs.rs/api-response/0.16.3
Admin
API Response is a Rust library providing consistent API response structures with built-in support...
Tokens:171,795
Snippets:1,430
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### BTreeMap upper_bound_mut Example

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Shows how to use `upper_bound_mut` with `Bound::Included`, `Bound::Excluded`, and `Bound::Unbounded` to get a mutable cursor positioned after the greatest key smaller than the bound. This API is experimental and requires the `btree_cursors` feature.

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

use std::collections::BTreeMap;
use std::ops::Bound;

let mut map = BTreeMap::from([
    (1, "a"),
    (2, "b"),
    (3, "c"),
    (4, "d"),
]);

let mut cursor = map.upper_bound_mut(Bound::Included(&3));
assert_eq!(cursor.peek_prev(), Some((&3, &mut "c")));
assert_eq!(cursor.peek_next(), Some((&4, &mut "d")));

let mut cursor = map.upper_bound_mut(Bound::Excluded(&3));
assert_eq!(cursor.peek_prev(), Some((&2, &mut "b")));
assert_eq!(cursor.peek_next(), Some((&3, &mut "c")));

let mut cursor = map.upper_bound_mut(Bound::Unbounded);
assert_eq!(cursor.peek_prev(), Some((&4, &mut "d")));
assert_eq!(cursor.peek_next(), None);

```

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

### Rust: Usage example for ErrPath construction

Source: https://docs.rs/api-response/0.16.3/src/api_response/error_code/errpath.rs.html

Demonstrates the construction of `ErrPathRoot`, `ErrPathParent`, and `ErrPath` by chaining methods and accessing their `path()` representation.

```rust
const ERR_PATH_ROOT: ErrPathRoot = ErrPathRoot::X99("name1");
        const ERR_PATH_PARENT: ErrPathParent = ERR_PATH_ROOT.Y01("name2");
        const ERR_PATH: ErrPath = ERR_PATH_PARENT.Z20("name3");

        assert_eq!("X99(name1)", ERR_PATH_ROOT.path());
        assert_eq!("X99(name1)/Y01(name2)", ERR_PATH_PARENT.path());
        assert_eq!("X99(name1)/Y01(name2)/Z20(name3)", ERR_PATH.path());
```

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

### Create BTreeMap with Allocator Example

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Shows how to create a new, empty `BTreeMap` using a specific allocator, such as `Global`. This API is experimental and requires the `btreemap_alloc` feature.

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

use std::collections::BTreeMap;
use std::alloc::Global;

let mut map = BTreeMap::new_in(Global);

// entries can now be inserted into the empty map
map.insert(1, "a");

```

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

### Using memory allocated elsewhere with Vec::from_raw_parts

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

This example shows how to create a Vec from memory allocated using `std::alloc::alloc`. It's crucial to ensure the layout used for allocation matches the requirements of `Vec::from_raw_parts` and that the memory is properly managed to avoid leaks or undefined behavior.

```rust
use std::alloc::{alloc, Layout};

fn main() {
    let layout = Layout::array::<u32>(16).expect("overflow cannot happen");

    let vec = unsafe {
        let mem = alloc(layout).cast::<u32>();
        if mem.is_null() {
            return;
        }

        mem.write(1_000_000);

        Vec::from_raw_parts(mem, 1, 16)
    };

    assert_eq!(vec, &[1_000_000]);
    assert_eq!(vec.capacity(), 16);
}
```

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

### Deserialize Implementation for String

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/trait.Deserialize.html

Example of how the Deserialize trait is implemented for the String type.

```APIDOC
### impl<'de> Deserialize<'de> for String

#### fn deserialize<D>(
    deserializer: D,
) -> Result<String, <D as Deserializer<'de>>::Error>
where
    D: Deserializer<'de>,

```

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

### Rebuilding a Vec from its parts

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

This example demonstrates how to take ownership of a Vec's allocation, modify its contents, and then rebuild it using `Vec::from_raw_parts`. Ensure that the original Vec is not dropped before calling `from_raw_parts` to avoid double-freeing memory.

```rust
use std::ptr;
use std::mem;

let v = vec![1, 2, 3];

// Prevent running `v`'s destructor so we are in complete control
// of the allocation.
let mut v = mem::ManuallyDrop::new(v);

// Pull out the various important pieces of information about `v`
let p = v.as_mut_ptr();
let len = v.len();
let cap = v.capacity();

unsafe {
    // Overwrite memory with 4, 5, 6
    for i in 0..len {
        ptr::write(p.add(i), 4 + i);
    }

    // Put everything back together into a Vec
    let rebuilt = Vec::from_raw_parts(p, len, cap);
    assert_eq!(rebuilt, [4, 5, 6]);
}
```

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

### Get API Version

Source: https://docs.rs/api-response/0.16.3/src/api_response/meta.rs.html

Retrieves the API version string if available. Returns `None` if the API version is not set.

```rust
pub const fn api_version(&self) -> Option<&String> {
        self.api_version.as_ref()
    }
```

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

### Deserialize Implementation for f64

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/trait.Deserialize.html

Example of how the Deserialize trait is implemented for the 64-bit floating-point number type.

```APIDOC
### impl<'de> Deserialize<'de> for f64

#### fn deserialize<D>(
    deserializer: D,
) -> Result<f64, <D as Deserializer<'de>>::Error>
where
    D: Deserializer<'de>,

```

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

### BTreeMap lower_bound_mut Example

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Demonstrates using `lower_bound_mut` with different `Bound` types to position a mutable cursor before the smallest key greater than or equal to, greater than, or the smallest key in the map. Requires the `btree_cursors` feature.

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

use std::collections::BTreeMap;
use std::ops::Bound;

let mut map = BTreeMap::from([
    (1, "a"),
    (2, "b"),
    (3, "c"),
    (4, "d"),
]);

let mut cursor = map.lower_bound_mut(Bound::Included(&2));
assert_eq!(cursor.peek_prev(), Some((&1, &mut "a")));
assert_eq!(cursor.peek_next(), Some((&2, &mut "b")));

let mut cursor = map.lower_bound_mut(Bound::Excluded(&2));
assert_eq!(cursor.peek_prev(), Some((&2, &mut "b")));
assert_eq!(cursor.peek_next(), Some((&3, &mut "c")));

let mut cursor = map.lower_bound_mut(Bound::Unbounded);
assert_eq!(cursor.peek_prev(), None);
assert_eq!(cursor.peek_next(), Some((&1, &mut "a")));

```

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

### Using unwrap to get Ok value or panic

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/type.ApiResult.html

Use unwrap to retrieve the Ok value. This method will panic if the Result is an Err, so it's generally discouraged in favor of safer alternatives.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

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

### Mutably iterating over a BTreeMap sub-range

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Use `range_mut` to get a mutable iterator over a sub-range. This allows in-place modification of values within the specified range. Panics if the range start is greater than the end, or if start equals end with both bounds excluded.

```rust
use std::collections::BTreeMap;

let mut map: BTreeMap<&str, i32> =
    [("Alice", 0), ("Bob", 0), ("Carol", 0), ("Cheryl", 0)].into();
for (_, balance) in map.range_mut("B".."Cheryl") {
    *balance += 100;
}
for (name, balance) in &map {
    println!("{name} => {balance}");
}
```

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

### Clear BTreeMap Example

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Demonstrates how to remove all elements from a `BTreeMap` using the `clear` method, leaving it empty. This is a standard operation for managing map contents.

```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.clear();
assert!(a.is_empty());

```

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

### Iterating over a BTreeMap sub-range

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Use `range` with inclusive and exclusive bounds to iterate over a specific portion of the map. Panics if the range start is greater than the end, or if start equals end with both bounds excluded.

```rust
use std::collections::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range((Included(&4), Included(&8))) {
    println!(ירת{key}: {value});
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());
```

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

### Macros

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/index.html

Macros available in the prelude.

```APIDOC
## Macro: api_err

### Description
Quickly create an `ApiError` builder `ApiErr` and collect error code mode information.

### Usage
```rust
// Example usage (conceptual)
let error = api_err!("some_code", "some_message");
```
```

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

### Create Vec with Capacity and Allocator

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Demonstrates creating a `Vec` with a specified initial capacity using a custom allocator. Shows how the vector behaves with and without reallocations.

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

use std::alloc::System;

let mut vec = Vec::with_capacity_in(10, System);

// The vector contains no items, even though it has capacity for more
assert_eq!(vec.len(), 0);
assert!(vec.capacity() >= 10);

// These are all done without reallocating...
for i in 0..10 {
    vec.push(i);
}
assert_eq!(vec.len(), 10);
assert!(vec.capacity() >= 10);

// ...but this may make the vector reallocate
vec.push(11);
assert_eq!(vec.len(), 11);
assert!(vec.capacity() >= 11);

// A vector of a zero-sized type will always over-allocate, since no
// allocation is necessary
let vec_units = Vec::<(), System>::with_capacity_in(10, System);
assert_eq!(vec_units.capacity(), usize::MAX);

```

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

### get

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTree.html

Retrieves a reference to the value associated with a given key.

```APIDOC
## get<Q>(&self, key: &Q) -> Option<&V>

### Description
Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form _must_ match the ordering on the key type.

### Method
`get`

### Parameters
- `key`: `&Q` - The key to search for.

### Returns
`Option<&V>` - An Option containing a reference to the value if the key is found, otherwise None.
```

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

### default

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Creates an empty `BTreeMap`.

```APIDOC
## fn default() -> BTreeMap<K, V>

### Description
Creates an empty `BTreeMap`.

### Method
`default()`

### Parameters
None

### Response
An empty `BTreeMap`.
```

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

### get

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Retrieves a reference to the value corresponding to the given key.

```APIDOC
## get

### Description
Returns a reference to the value corresponding to the key. The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

### Method
`pub fn get<Q>(&self, key: &Q) -> Option<&V>`

### Type Parameters
- `Q`: The type of the key to search for, which must be comparable to the map's key type.

### Parameters
- **key**: `&Q` - A reference to the key to look up.

### Returns
- `Option<&V>`: An `Option` containing a reference to the value if the key is found, otherwise `None`.
```

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

### ErrPath Methods

Source: https://docs.rs/api-response/0.16.3/src/api_response/error_code/errpath.rs.html

Provides a default constructor, a method to get the full path string, and a method to calculate the combined path flag for the deepest error path level.

```rust
impl ErrPath {
    #[inline]
    pub const fn default() -> Self {
        Self {
            parent: ErrPathParent::default(),
            name: "",
            flag: 0,
        }
    }
    #[inline]
    pub fn path(&self) -> String {
        self.to_string()
    }
    #[inline]
    pub const fn path_flag(&self) -> u32 {
        (self.parent.path_flag() * 100) + self.flag as u32
    }
}
```

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

### Get Error Path

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrDecl.html

Retrieves a reference to the ErrPath of the error.

```rust
pub const fn err_path(&self) -> &ErrPath
```

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

### default

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTree.html

Creates an empty `BTreeMap`.

```APIDOC
## fn default() -> BTreeMap<K, V>

### Description
Creates an empty `BTreeMap`.
```

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

### Basic BTreeMap Usage

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Demonstrates the fundamental insertion and retrieval of key-value pairs in a BTreeMap.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
```

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

### Get Error Type

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrDecl.html

Retrieves a reference to the ErrType of the error.

```rust
pub const fn err_type(&self) -> &ErrType
```

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

### Get Vec Length

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Returns the number of elements currently in the vector.

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

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

### Initializing Vector Elements via `as_mut_ptr`

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Shows how to initialize vector elements by writing to a raw mutable pointer obtained from `as_mut_ptr` before setting the vector's length.

```rust
// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_mut_ptr();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        *x_ptr.add(i) = i as i32;
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

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

### Get Error Flag

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrDecl.html

Retrieves the u32 flag associated with the error.

```rust
pub const fn err_flag(&self) -> u32
```

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

### Create a new BTreeMap

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Demonstrates how to create a new, empty BTreeMap. No allocation is performed by this method itself.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();

// entries can now be inserted into the empty map
map.insert(1, "a");
```

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

### new_in

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Creates a new empty BTreeMap with a specified allocator. This is a nightly-only experimental API.

```APIDOC
## new_in

### Description
Makes a new empty BTreeMap with a reasonable choice for B. This is a nightly-only experimental API.

### Method
`pub const fn new_in(alloc: A) -> BTreeMap<K, V, A>`

### Type Parameters
- `A`: The allocator type.

### Parameters
- **alloc**: `A` - The allocator to use for the BTreeMap.

### Returns
- `BTreeMap<K, V, A>`: A new, empty BTreeMap.

### Examples
```rust
use std::collections::BTreeMap;
use std::alloc::Global;

let mut map = BTreeMap::new_in(Global);

// entries can now be inserted into the empty map
map.insert(1, "a");
```
```

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

### Get XML Representation

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/struct.ErrDeclTally.html

Serializes the error declarations into an XML string.

```rust
pub fn xml(&self) -> String
```

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

### Get JSON Representation

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/struct.ErrDeclTally.html

Serializes the error declarations into a JSON string.

```rust
pub fn json(&self) -> String
```

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

### new_in

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTree.html

Creates a new empty BTreeMap with a specified allocator. This is a nightly-only experimental API.

```APIDOC
## new_in(alloc: A) -> BTreeMap<K, V, A>

### Description
Makes a new empty BTreeMap with a reasonable choice for B.

### Method
`new_in`

### Parameters
- `alloc`: `A` - The allocator to use for the BTreeMap.

### Returns
`BTreeMap<K, V, A>` - A new, empty BTreeMap.

### Examples
```rust
use std::collections::BTreeMap;
use std::alloc::Global;

let mut map = BTreeMap::new_in(Global);

// entries can now be inserted into the empty map
map.insert(1, "a");
```
```

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

### ErrPathRoot Methods

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrPathRoot.html

Provides methods to get the name and flag of an ErrPathRoot instance.

```APIDOC
## ErrPathRoot

### Summary
```rust
#[non_exhaustive]
pub struct ErrPathRoot { /* private fields */ }
```

### Methods

#### `name(&self) -> &'static str`
Returns the static string name of the error path root.

#### `flag(&self) -> u8`
Returns the flag associated with the error path root. The value range is from 0 to 99 inclusive.
```

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

### Initializing Vector Elements via `as_non_null`

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Shows how to initialize vector elements by writing to a `NonNull` pointer obtained from `as_non_null` before setting the vector's length. Requires the `box_vec_non_null` feature.

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

// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_non_null();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        x_ptr.add(i).write(i as i32);
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

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

### LocalKeyErrDecl Constructor

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/struct.LocalKeyErrDecl.html

Creates a new instance of LocalKeyErrDecl.

```APIDOC
## pub const fn new( err_type: ErrType, err_path: &'static LocalKey<ErrPath>, ) -> Self

### Description
Creates a new instance of `LocalKeyErrDecl` with the specified error type and path.

### Parameters
- **err_type** (ErrType) - The type of the error.
- **err_path** (&'static LocalKey<ErrPath>) - The static path of the error.
```

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

### Get Error Text

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrDecl.html

Retrieves the static string slice representing the error text.

```rust
pub const fn text(&self) -> &'static str
```

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

### from (array)

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Allocates a `Vec<T>` and fills it by cloning `s`’s items.

```APIDOC
## fn from(s: &[T; N]) -> Vec<T>

### Description
Allocates a `Vec<T>` and fills it by cloning `s`’s items.

### Method
`from`

### Parameters
#### Path Parameters
- **s** (*&[T; N]*) - Required - The array to clone elements from.

### Response
#### Success Response
- **Vec<T>** - A new vector containing cloned elements from the array.
```

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

### Get Error Path Flag

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrDecl.html

Retrieves the u32 flag associated with the error path.

```rust
pub const fn err_path_flag(&self) -> u32
```

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

### Get Metadata from ApiResponse

Source: https://docs.rs/api-response/0.16.3/api_response/enum.ApiResponse.html

Returns an Option containing a reference to the metadata if present in the ApiResponse.

```rust
pub const fn get_meta(&self) -> Option<&Meta>
```

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

### Enums

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/index.html

Enums available in the prelude.

```APIDOC
## Enum: MaybeString

### Description
Represents a string that might be present or absent.
```

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

### Get Text Vector Representation

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/struct.ErrDeclTally.html

Returns a text-based vector representation of the error declarations.

```rust
pub fn text_vec(&self) -> ErrDeclVecText
```

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

### from (slice)

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Allocates a `Vec<T>` and fills it by cloning `s`’s items.

```APIDOC
## fn from(s: &[T]) -> Vec<T>

### Description
Allocates a `Vec<T>` and fills it by cloning `s`’s items.

### Method
`from`

### Parameters
#### Path Parameters
- **s** (*&[T]*) - Required - The slice to clone elements from.

### Response
#### Success Response
- **Vec<T>** - A new vector containing cloned elements from the slice.
```

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

### Get Text Tree Representation

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/struct.ErrDeclTally.html

Returns a text-based tree representation of the error declarations.

```rust
pub fn text_tree(&self) -> ErrDeclTreeText
```

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

### from (BinaryHeap)

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Converts a `BinaryHeap<T>` into a `Vec<T>`. This conversion requires no data movement or allocation, and has constant time complexity.

```APIDOC
## fn from(heap: BinaryHeap<T, A>) -> Vec<T, A>

### Description
Converts a `BinaryHeap<T>` into a `Vec<T>`. This conversion requires no data movement or allocation, and has constant time complexity.

### Method
`from`

### Parameters
#### Path Parameters
- **heap** (*BinaryHeap<T, A>*) - Required - The binary heap to convert.

### Response
#### Success Response
- **Vec<T, A>** - A vector containing the elements from the binary heap.
```

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

### from_output

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/type.ApiResult.html

Constructs a Result from its `Output` type. This is a nightly-only experimental API.

```APIDOC
## fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

### Description
Constructs the type from its `Output` type. This is a nightly-only experimental API.

### Method
`from_output`

### Parameters
* `output` (<Result<T, E> as Try>::Output) - The output type to construct the Result from.
```

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

### Get Error Declaration Tree

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/struct.ErrDeclTally.html

Returns a structured tree representation of the error declarations.

```rust
pub fn tree(&self) -> ErrDeclTree
```

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

### DefaultMeta::with_pagination() Method

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.DefaultMeta.html

Sets the pagination metadata for the DefaultMeta instance. Accepts an Option<Pagination>.

```rust
pub const fn with_pagination(self, pagination: Option<Pagination>) -> Self
```

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

### Get Total Error Declarations

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/struct.ErrDeclTally.html

Returns a reference to the vector containing all error declarations.

```rust
pub const fn total(&self) -> &Vec<ErrDecl>
```

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

### ErrBrief Methods

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrBrief.html

Provides methods to get the error message and code from an ErrBrief instance.

```APIDOC
## impl ErrBrief

### pub const fn message(&self) -> &'static str
Gets the error message.

### pub const fn code(&self) -> u32
Gets the error code. The value range of the code is from 1000000000 to 4293999999 inclusive.
```

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

### Deserialize Implementation for Option<T>

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/trait.Deserialize.html

Example of how the Deserialize trait is implemented for a generic option type.

```APIDOC
### impl<'de, T> Deserialize<'de> for Option<T>

#### fn deserialize<D>(
    deserializer: D,
) -> Result<Option<T>, <D as Deserializer<'de>>::Error>
where
    D: Deserializer<'de>,
    T: Deserialize<'de>,

```

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

### Create SuccessResponse with Data and Meta

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.SuccessResponse.html

Constructs a new SuccessResponse instance with both data and metadata. This is a const function, allowing for compile-time creation.

```rust
pub const fn new(data: Data, meta: Meta) -> Self
```

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

### Derive Macros

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/index.html

Derive macros available in the prelude.

```APIDOC
## Derive Macro: Deserialize

### Description
Derive macro for the `Deserialize` trait.

## Derive Macro: Serialize

### Description
Derive macro for the `Serialize` trait.
```

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

### Deserialize Implementation for Vec<T>

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/trait.Deserialize.html

Example of how the Deserialize trait is implemented for a generic vector type.

```APIDOC
### impl<'de, T> Deserialize<'de> for Vec<T>

#### fn deserialize<D>(
    deserializer: D,
) -> Result<Vec<T>, <D as Deserializer<'de>>::Error>
where
    D: Deserializer<'de>,
    T: Deserialize<'de>,

```

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

### Deserialize Implementation for bool

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/trait.Deserialize.html

Example of how the Deserialize trait is implemented for the boolean primitive type.

```APIDOC
### impl<'de> Deserialize<'de> for bool

#### fn deserialize<D>(
    deserializer: D,
) -> Result<bool, <D as Deserializer<'de>>::Error>
where
    D: Deserializer<'de>,

```

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

### DefaultMeta::pagination() Method

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.DefaultMeta.html

Returns a reference to the optional pagination metadata.

```rust
pub const fn pagination(&self) -> Option<&Pagination>
```

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

### Get Unique Error Declarations

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/struct.ErrDeclTally.html

Returns a new vector containing only the unique error declarations.

```rust
pub fn unique(&self) -> Vec<ErrDecl>
```

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

### DefaultMeta Implementations

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.DefaultMeta.html

This section details the available implementations for the DefaultMeta struct, including constructor methods and field accessors.

```APIDOC
### impl DefaultMeta

#### Public Methods

- `pub fn new() -> Self`: Creates a new instance of `DefaultMeta`.
- `pub fn with_request_id(self, request_id: impl Into<MaybeString>) -> Self`: Sets the `request_id`.
- `pub fn with_user(self, user: Option<UserMeta>) -> Self`: Sets the `user` metadata.
- `pub const fn with_pagination(self, pagination: Option<Pagination>) -> Self`: Sets the `pagination` details.
- `pub const fn with_rate_limit(self, rate_limit: Option<RateLimit>) -> Self`: Sets the `rate_limit` information.
- `pub const fn with_cost(self, cost: Option<Cost>) -> Self`: Sets the `cost` details.
- `pub fn with_api_version(self, api_version: impl Into<MaybeString>) -> Self`: Sets the `api_version`.
- `pub fn insert_custom(self, key: impl Into<String>, value: impl Into<String>) -> Self`: Inserts a custom key-value pair.

#### Accessor Methods

- `pub const fn request_id(&self) -> Option<&String>`: Returns the `request_id`.
- `pub const fn user(&self) -> Option<&UserMeta>`: Returns the `user` metadata.
- `pub const fn pagination(&self) -> Option<&Pagination>`: Returns the `pagination` details.
- `pub const fn rate_limit(&self) -> Option<&RateLimit>`: Returns the `rate_limit` information.
- `pub const fn cost(&self) -> Option<&Cost>`: Returns the `cost` details.
- `pub const fn api_version(&self) -> Option<&String>`: Returns the `api_version`.
- `pub fn custom(&self) -> &HashMap<String, String>`: Returns a reference to the custom fields.
- `pub fn custom_kv(&self, key: impl AsRef<str>) -> Option<&String>`: Returns the value for a specific custom key.
```

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

### Create New BTreeMap with Allocator

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTree.html

Instantiate a new, empty BTreeMap with a specified allocator using `new_in`. This nightly-only API requires the `btreemap_alloc` feature.

```rust
use std::collections::BTreeMap;
use std::alloc::Global;

let mut map = BTreeMap::new_in(Global);

// entries can now be inserted into the empty map
map.insert(1, "a");

```

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

### TryFrom

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrPath.html

Provides functionality to attempt conversion from one type to another, returning a `Result`.

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

### Description
Performs a fallible conversion from type `U` to type `T`.

### Method
`try_from`

### Parameters
#### Path Parameters
- **value** (U) - Required - The value to convert.
```

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

### Deserialize Implementation for i32

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/trait.Deserialize.html

Example of how the Deserialize trait is implemented for the 32-bit signed integer type.

```APIDOC
### impl<'de> Deserialize<'de> for i32

#### fn deserialize<D>(
    deserializer: D,
) -> Result<i32, <D as Deserializer<'de>>::Error>
where
    D: Deserializer<'de>,

```

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

### Get Immutable Vec Reference

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

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

```rust
fn as_ref(&self) -> &Vec<T, A>
```

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

### Testing the `api_err!` Macro

Source: https://docs.rs/api-response/0.16.3/src/api_response/error_code/tally.rs.html

Demonstrates the usage of the `api_err!` macro for creating `ApiError` instances with different configurations. Includes assertions for string representation and error codes.

```rust
#[test]
    fn macro_api_err() {
        const ET: ErrType = ErrType::T1100("The operation was cancelled.");
        const EP_LV1: ErrPathRoot = ErrPathRoot::X00("product");
        const EP_LV2: ErrPathParent = EP_LV1.Y01("system");
        const EP_LV3: ErrPath = EP_LV2.Z20("module");
        const EC: ErrDecl = ErrDecl::new(ET, EP_LV3);

        let ae0: ApiError = api_err!(EC);
        assert_eq!("The operation was cancelled. ErrCode(1100000120)", ae0.to_string());
        let ae1: ApiError = api_err!(ET, EP_LV3);
        let _ = api_err!(ET, EP_LV3);
        assert_eq!("The operation was cancelled. ErrCode(1100000120)", ae1.to_string());
        let ae2: ApiError = api_err!(ET, "This is new message.", EP_LV3);
        assert_eq!("This is new message. ErrCode(1100000120)", ae2.to_string());

        thread_local! {static EP_LV3_1:ErrPath = ErrPathRoot::X01("product-2").Y01("system-2").Z02("module-2")}
        let ae3: ApiError = api_err!(ET, &EP_LV3_1);
        assert_eq!("The operation was cancelled. ErrCode(1100010102)", ae3.to_string());
        let ae4: ApiError = api_err!(ET, "This is new message-2.", &EP_LV3_1);
        assert_eq!("This is new message-2. ErrCode(1100010102)", ae4.to_string());

        let s = format!(‘{:?}’, tally_err_decl());
        println!(“{s}”);

        let tally: ErrDeclTally = tally_err_decl();
        for err_decl in tally.unique() {
            println!(“{err_decl}”);
        }
        assert_eq!(tally.unique().len(), 4);
        assert_eq!(tally.total().len(), 6);
        println!(“{}”, tally.json());
        println!(“{}”, tally.xml());
    }
```

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

### Get Immutable Slice Reference

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

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

```rust
fn as_ref(&self) -> &[T]
```

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

### Using set_len for FFI Buffers

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Demonstrates using `set_len` to manage a vector as a buffer for FFI calls, ensuring safety by verifying initialized elements and capacity.

```rust
pub fn get_dictionary(&self) -> Option<Vec<u8>> {
    // Per the FFI method's docs, "32768 bytes is always enough".
    let mut dict = Vec::with_capacity(32_768);
    let mut dict_length = 0;
    // SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that:
    // 1. `dict_length` elements were initialized.
    // 2. `dict_length` <= the capacity (32_768)
    // which makes `set_len` safe to call.
    unsafe {
        // Make the FFI call...
        let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);
        if r == Z_OK {
            // ...and update the length to what was initialized.
            dict.set_len(dict_length);
            Some(dict)
        } else {
            None
        }
    }
}
```

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

### DefaultMeta::api_version() Method

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.DefaultMeta.html

Returns a reference to the optional API version string.

```rust
pub const fn api_version(&self) -> Option<&String>
```

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

### Get Mutable Vec Reference

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Converts this type into a mutable reference of the (usually inferred) input type.

```rust
fn as_mut(&mut self) -> &mut Vec<T, A>
```

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

### X86

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrPathRoot.html

Constructs an ErrPathRoot with a given name.

```APIDOC
## X86

### Description
Constructs an ErrPathRoot with a given name.

### Signature
`pub const fn X86(name: &'static str) -> ErrPathRoot`
```

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

### Get Mutable Slice Reference

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Converts this type into a mutable reference of the (usually inferred) input type.

```rust
fn as_mut(&mut self) -> &mut [T]
```

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

### Iterate over BTreeMap Keys

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Explains how to get an iterator over the keys of a BTreeMap in sorted order. Useful for key-based operations.

```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(2, "b");
a.insert(1, "a");

let keys: Vec<_> = a.keys().cloned().collect();
assert_eq!(keys, [1, 2]);
```

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

### into_ok

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/type.ApiResult.html

Returns the contained `Ok` value, but never panics. This is an experimental API.

```APIDOC
## pub const fn into_ok(self) -> T

### Description
Returns the contained `Ok` value, but never panics. Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur.

### Method
`into_ok`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (T)
Returns the contained `Ok` value.

#### Response Example
None
```

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

### TryInto

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrPath.html

Provides functionality to attempt conversion into another type, returning a `Result`.

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

### Description
Performs a fallible conversion from the current type to type `U`.

### Method
`try_into`
```

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

### SuccessResponse Constructors and Methods

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.SuccessResponse.html

Provides methods for creating and manipulating SuccessResponse instances.

```APIDOC
## Implementations for SuccessResponse<Data, Meta>

### Constructors

- `pub const fn new(data: Data, meta: Meta) -> Self`
  Creates a new `SuccessResponse` with both data and metadata.
- `pub const fn from_data(data: Data) -> Self`
  Creates a new `SuccessResponse` with data, but no metadata.
```

```APIDOC
### Methods

- `pub fn with_meta(self, meta: Meta) -> Self`
  Returns a new `SuccessResponse` with the provided metadata added.
- `pub fn set_meta(&mut self, meta: Meta) -> &mut Self`
  Sets or updates the metadata on an existing `SuccessResponse`.
```

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

### Get Metadata from ApiResponse

Source: https://docs.rs/api-response/0.16.3/src/api_response/lib.rs.html

Returns an Option<&Meta> containing the metadata if present, or None otherwise. This is a const function.

```rust
pub const fn get_meta(&self) -> Option<&Meta> {
        match self {
            ApiResponse::Success(success_response) => success_response.meta.as_ref(),
            ApiResponse::Error(error_response) => error_response.meta.as_ref(),
        }
    }
```

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

### ApiResponse Constructor Methods

Source: https://docs.rs/api-response/0.16.3/src/api_response/lib.rs.html

Methods for creating ApiResponse instances for both success and error scenarios.

```APIDOC
impl<Data, Meta> ApiResponse<Data, Meta> {
    /// Creates a new success response with data and metadata.
    #[inline(always)]
    pub const fn new_success(data: Data, meta: Meta) -> Self {
        Self::Success(SuccessResponse::new(data, meta))
    }
    /// Creates a success response from data only.
    #[inline(always)]
    pub const fn from_success(data: Data) -> Self {
        Self::Success(SuccessResponse::from_data(data))
    }
    /// Creates a success response from data only (alias).
    #[inline(always)]
    pub const fn from_success_data(data: Data) -> Self {
        Self::Success(SuccessResponse::from_data(data))
    }
    /// Creates a new error response with an ApiError and metadata.
    #[inline(always)]
    pub const fn new_error(error: ApiError, meta: Meta) -> Self {
        Self::Error(ErrorResponse::new(error, meta))
    }
    /// Creates an error response from an ApiError.
    #[inline(always)]
    pub const fn from_error(error: ApiError) -> Self {
        Self::Error(ErrorResponse::from_error(error))
    }
    /// Creates an error response from a code and message.
    #[inline(always)]
    pub fn from_error_msg(code: impl Into<u32>, message: impl Into<String>) -> Self {
        Self::Error(ErrorResponse::from_error_msg(code, message))
    }
    /// Creates an error response from an error source.
    #[inline(always)]
    pub fn from_error_source(
// ... rest of the method signature is truncated in the source
```

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

### entry

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Gets the given key’s corresponding entry in the map for in-place manipulation. Useful for conditional insertion or modification.

```APIDOC
## pub fn entry(&mut self, key: K) -> Entry<'_, K, V, A>

### Description
Gets the given key’s corresponding entry in the map for in-place manipulation.

### Examples
```rust
use std::collections::BTreeMap;

let mut count: BTreeMap<&str, usize> = BTreeMap::new();

// count the number of occurrences of letters in the vec
for x in ["a", "b", "a", "c", "a", "b"] {
    count.entry(x).and_modify(|curr| *curr += 1).or_insert(1);
}

assert_eq!(count["a"], 3);
assert_eq!(count["b"], 2);
assert_eq!(count["c"], 1);
```
```

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

### DefaultMeta::new() Constructor

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.DefaultMeta.html

Creates a new instance of DefaultMeta with default values for all fields.

```rust
pub fn new() -> Self
```

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

### Get the number of elements in a BTreeMap

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Returns the number of elements currently stored in the BTreeMap. Useful for checking map size.

```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
```

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

### Implement Error Trait: cause() (Deprecated)

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.InvalidErrTypeFlag.html

Deprecated method to get the underlying cause of the error. Replaced by Error::source.

```rust
fn cause(&self) -> Option<&dyn Error>
```

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

### DefaultMeta::with_cost() Method

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.DefaultMeta.html

Sets the cost metadata for the DefaultMeta instance. Accepts an Option<Cost>.

```rust
pub const fn with_cost(self, cost: Option<Cost>) -> Self
```

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

### Convert VecDeque to Vec (O(1))

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Converts a VecDeque into a Vec without re-allocation when the deque's data is contiguous at the start of its buffer.

```rust
use std::collections::VecDeque;

// This one is *O*(1).
let deque: VecDeque<_> = (1..5).collect();
let ptr = deque.as_slices().0.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);
```

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

### FromResidual<Yeet<E>> for Result<T, F>

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/type.ApiResult.html

Constructs a `Result<T, F>` from a `Yeet<E>`, where `F` can be created from `E`. This is an experimental API.

```APIDOC
## impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
where F: From<E>,

### fn from_residual(_: Yeet<E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (`try_trait_v2`)
Constructs the type from a compatible `Residual` type. Read more
```

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

### len() - Get the number of elements

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Returns the number of elements currently in the vector, also known as its length. This is a constant time operation.

```APIDOC
## pub const fn len(&self) -> usize

### Description
Returns the number of elements in the vector, also referred to as its ‘length’.

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

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

### Using unwrap_err to get Err value or panic

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/type.ApiResult.html

Retrieves the Err value. This method will panic if the Result is an Ok, so use it cautiously.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

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

### DefaultMeta::with_user() Method

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/struct.DefaultMeta.html

Sets the user metadata for the DefaultMeta instance. Accepts an Option<UserMeta>.

```rust
pub fn with_user(self, user: Option<UserMeta>) -> Self
```

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

### Get Last Key-Value Pair

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Retrieves the last key-value pair (maximum key) from the map. Returns None if the map is empty.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.last_key_value(), Some((&2, &"a")));
```

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

### X70

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.ErrPathRoot.html

Constructs an ErrPathRoot with a given name.

```APIDOC
## X70

### Description
Constructs an ErrPathRoot with a given name.

### Signature
`pub const fn X70(name: &'static str) -> ErrPathRoot`
```

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

### Get First Key-Value Pair

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclTreeText.html

Retrieves the first key-value pair (minimum key) from the map. Returns None if the map is empty.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
assert_eq!(map.first_key_value(), None);
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.first_key_value(), Some((&1, &"b")));
```

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

### Implement Error Trait: provide() (Nightly Experimental)

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.InvalidErrTypeFlag.html

Provides type-based access to context for error reports. This is a nightly-only experimental API.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

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

### Create Success Response from Data (Alternative)

Source: https://docs.rs/api-response/0.16.3/api_response/enum.ApiResponse.html

Another method to construct a new ApiResponse::Success variant using only the provided data.

```rust
pub const fn from_success_data(data: Data) -> Self
```

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

### Get Specific Custom Metadata Value

Source: https://docs.rs/api-response/0.16.3/src/api_response/meta.rs.html

Retrieves a specific custom metadata value by its key. Returns `None` if the key does not exist.

```rust
pub fn custom_kv(&self, key: impl AsRef<str>) -> Option<&String> {
        self.custom.get(key.as_ref())
    }
```

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

### Traits

Source: https://docs.rs/api-response/0.16.3/api_response/prelude/index.html

Traits available in the prelude.

```APIDOC
## Trait: ApiSuccessResponse

### Description
Trait for types that can be used as a successful API response.

## Trait: Deserialize

### Description
A **data structure** that can be deserialized from any data format supported by Serde.

## Trait: DeserializeOwned

### Description
A data structure that can be deserialized without borrowing any data from the deserializer.

## Trait: IntoError

### Description
Trait for types that can be converted into an API error.

## Trait: Serialize

### Description
A **data structure** that can be serialized into any data format supported by Serde.
```

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

### Implement Error Trait: description() (Deprecated)

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/struct.InvalidErrTypeFlag.html

Deprecated method to get a string description of the error. Use the Display impl or to_string() instead.

```rust
fn description(&self) -> &str
```

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

### ErrPathRoot Methods

Source: https://docs.rs/api-response/0.16.3/src/api_response/error_code/errpath.rs.html

Provides default constructor, path string generation, flag retrieval, and fallible construction from a flag and name for `ErrPathRoot`.

```rust
impl ErrPathRoot {
    #[inline]
    pub const fn default() -> Self {
        Self { name: "", flag: 0 }
    }
    #[inline]
    pub fn path(&self) -> String {
        self.to_string()
    }
    #[inline]
    pub const fn path_flag(&self) -> u32 {
        self.flag as u32
    }
    pub fn try_from<T: TryInto<u8>>(flag: T, name: &'static str) -> Result<Self, InvalidErrPathFlag> {
        let x: u8 = flag.try_into().map_err(|_| InvalidErrPathFlag::new())?;
        if x > 99 {
            Err(InvalidErrPathFlag::new())
        } else {
            Ok(Self { name, flag: x })
        }
    }
    pub fn try_to_child<T: TryInto<u8>>(
        self,
        child_flag: T,
        child_name: &'static str,
    ) -> Result<ErrPathParent, InvalidErrPathFlag> {
        let x: u8 = child_flag.try_into().map_err(|_| InvalidErrPathFlag::new())?;
        if x > 99 {
            Err(InvalidErrPathFlag::new())
        } else {
            Ok(ErrPathParent {
                root: self,
                name: child_name,
                flag: x,
            })
        }
    }
}
```

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

### Get Immutable Slice View of Vec

Source: https://docs.rs/api-response/0.16.3/api_response/error_code/tally/type.ErrDeclVecText.html

Obtain an immutable slice covering the entire vector's contents using `as_slice`. This is equivalent to `&s[..]`.

```rust
use std::io::{self, Write};
let buffer = vec![1, 2, 3, 5, 8];
io::sink().write(buffer.as_slice()).unwrap();
```
Tokens:
Raw