krb5-rs

https://docs.rs/krb5-rs/0.1.0/krb5_rs/
Admin
Pure Rust implementation of Kerberos V5 with GSSAPI, SPNEGO, and PKINIT support, requiring no C FFI...
Tokens:386,740
Snippets:2,590
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example: Create Vec from Slice

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AuthorizationData.html

Demonstrates creating a Vec<T> from a slice by cloning its elements.

```rust
assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);
```

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

### Vec<T, System> Example

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.EtypeInfo2.html

Demonstrates creating a Vec with a specific allocator (System), pushing elements, and rebuilding it from its parts.

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

use std::alloc::System;

let mut v: Vec<i32, System> = Vec::new_in(System);
v.push(-1);
v.push(0);
v.push(1);

let (ptr, len, cap, alloc) = v.into_parts_with_alloc();

let rebuilt = unsafe {
    // We can now make changes to the components, such as
    // transmuting the raw pointer to a compatible type.
    let ptr = ptr.cast::<u32>();

    Vec::from_parts_in(ptr, len, cap, alloc)
};
assert_eq!(rebuilt, [4294967295, 0, 1]);
```

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

### Example: Create Vec from Array

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AuthorizationData.html

Demonstrates creating a Vec<T> from an array reference by cloning its elements.

```rust
assert_eq!(Vec::from(&[1, 2, 3]), vec![1, 2, 3]);
```

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

### Vec Capacity Example

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Shows how to initialize a vector with a specific capacity and verify that the capacity is at least the requested amount after adding elements.

```rust
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);
```

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

### Example: Create Vec from Mutable Slice

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AuthorizationData.html

Demonstrates creating a Vec<T> from a mutable slice by cloning its elements.

```rust
assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);
```

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

### Vec with Custom Allocator Example

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Demonstrates creating a vector with a specific capacity using a custom allocator and observing its behavior during element additions.

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

```

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

### Example: Create Vec from Mutable Array

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AuthorizationData.html

Demonstrates creating a Vec<T> from a mutable array reference by cloning its elements.

```rust
assert_eq!(Vec::from(&mut [1, 2, 3]), vec![1, 2, 3]);
```

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

### Get Immutable Raw Pointer to Vector Buffer

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Use `as_ptr` to get a raw pointer to the vector's buffer. Ensure the vector outlives the pointer and do not mutate the memory through this pointer.

```rust
let x = vec![1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(*x_ptr.add(i), 1 << i);
    }
}
```

```rust
unsafe {
    let mut v = vec![0, 1, 2];
    let ptr1 = v.as_ptr();
    let _ = ptr1.read();
    let ptr2 = v.as_mut_ptr().offset(2);
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`
    // because it mutated a different element:
    let _ = ptr1.read();
}
```

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

### Recycle Vec with Exotic Types (Example)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Shows an example of a runtime limitation where recycling is not yet supported for exotic types like slices or trait objects. This is due to temporary implementation constraints of Recyclable.

```rust
#![feature(vec_recycle, transmutability)]
let mut storage: Vec<&[&str]> = Vec::new();

for input in inputs {
    let mut buffer: Vec<&str> = storage.recycle();
    buffer.extend(input.split(" "));
    process(&buffer);
    storage = buffer.recycle();
}
```

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

### PaEncTsEnc::type_id

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.PaEncTsEnc.html

Gets the `TypeId` of `self`.

```APIDOC
## T::type_id

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

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

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

### Get Mutable Raw Pointer to Vector Buffer

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Use `as_mut_ptr` to get a mutable raw pointer to the vector's buffer. This allows in-place modification of elements before setting the vector's length. Ensure the vector outlives the pointer.

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

```rust
unsafe {
    let mut v = vec![0];
    let ptr1 = v.as_mut_ptr();
    ptr1.write(1);
    let ptr2 = v.as_mut_ptr();
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`:
    ptr1.write(3);
}
```

```rust
use std::mem::{ManuallyDrop, MaybeUninit};

let mut v = ManuallyDrop::new(vec![0, 1, 2]);
let ptr = v.as_mut_ptr();
let capacity = v.capacity();
let slice_ptr: *mut [MaybeUninit<i32>] = 
    std::ptr::slice_from_raw_parts_mut(ptr.cast(), capacity);
drop(unsafe { Box::from_raw(slice_ptr) });
```

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

### EtypeInfoEntry::type_id

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EtypeInfoEntry.html

Gets the TypeId of an EtypeInfoEntry instance.

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

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

### Method
`type_id`

### Returns
- `TypeId`: The type identifier of the instance.
```

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

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

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.TypedDataItem.html

Gets the `TypeId` of `self`.

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

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

### Method
`type_id`

### Parameters
- **self**: `&self` - The instance of the type.
```

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

### fn fmt_list(self) -> FmtList<Self>

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.TypedDataItem.html

Formats each item in a sequence.

```APIDOC
## fn fmt_list(self) -> FmtList<Self>

### Description
Formats each item in a sequence.

### Method
`fmt_list`

### Parameters
- **self**: `Self` - The sequence to format.
```

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

### KdcOptions::opt_hardware_auth

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KdcOptions.html

Option for hardware authentication.

```APIDOC
## KdcOptions::opt_hardware_auth

### Description
Option for hardware authentication.

### Method
`KdcOptions::opt_hardware_auth()`

### Returns
- `KdcOptions`: An instance of KdcOptions with the hardware authentication option set.
```

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

### Get Vec Length

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Returns the number of elements currently in the vector.

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

```

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

### Type Identity

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EncryptedData.html

Provides a way to get the TypeId of the EncryptedData struct.

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

Gets the `TypeId` of `self`.

### Method
`type_id`

### Returns
- `TypeId`: The unique identifier for the type of `self`.
```

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

### try_from

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.ApRep.html

Performs the conversion.

```APIDOC
#### type Error = Infallible
The type returned in the event of a conversion error.
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
```

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

### Type Identity

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.AdCammac.html

Provides a way to get the TypeId of an AdCammac instance.

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

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

### Method
`type_id`

### Returns
- `TypeId` - The unique identifier for the type of `self`.
```

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

### Type Identity

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EncryptionKey.html

Provides the `type_id` method to get the unique identifier for the type of `self`.

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

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

### Method
`type_id`

### Returns
`TypeId` - The unique identifier for the type of `self`.
```

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

### try_from

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.AsRep.html

Performs the conversion.

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
where U: Into<T>,
Performs the conversion.
```

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

### Vec with Capacity in System Allocator

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AuthorizationData.html

Demonstrates creating a vector with a specific capacity using the System allocator and how push operations affect capacity and length. Also shows behavior with zero-sized types.

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

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

### Type ID Retrieval

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.Checksum.html

Provides a method to get the unique TypeId of a Checksum instance.

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

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

### Method
`type_id`

### Response
- TypeId - The unique identifier for the type of `self`.
```

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

### Clone Implementation for KerberosTime

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KerberosTime.html

Allows cloning KerberosTime instances.

```APIDOC
### impl Clone for KerberosTime

* `clone(&self) -> KerberosTime`: Returns a duplicate of the value.
* `clone_from(&mut self, source: &Self)`: Performs copy-assignment from a source.
```

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

### from_raw_parts_in

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Creates a `Vec<T, A>` directly from a pointer, a length, a capacity, and an allocator. This is a nightly-only experimental API.

```APIDOC
## from_raw_parts_in

### Description
Creates a `Vec<T, A>` directly from a pointer, a length, a capacity, and an allocator. This is a nightly-only experimental API.

### Method
`unsafe fn from_raw_parts_in(ptr: *mut T, length: usize, capacity: usize, alloc: A) -> Vec<T, A>`

### Parameters
- `ptr` (*mut T): A raw mutable pointer to the data.
- `length` (usize): The number of elements in the vector.
- `capacity` (usize): The allocated capacity of the vector.
- `alloc` (A): The allocator used for the vector.

### Response
- `Vec<T, A>`: A new `Vec<T, A>` created from the provided components.

### Request Example
```rust
#![feature(allocator_api)]
use std::alloc::System;
let data = vec![1, 2, 3];
let (ptr, len, cap) = data.into_raw_parts();
let vec = unsafe { Vec::from_raw_parts_in(ptr, len, cap, System) };
```

### Response Example
```rust
// Vec<i32, System> containing [1, 2, 3]
```
```

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

### Get Allocator Reference (Nightly)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Returns a reference to the underlying allocator used by the vector. This is an experimental API.

```rust
let allocator = vec.allocator();
```

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

### from_raw_parts_in

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AuthorizationData.html

Creates a `Vec<T, A>` directly from a pointer, a length, a capacity, and an allocator. This is a nightly-only experimental API.

```APIDOC
## pub const unsafe fn from_raw_parts_in( ptr: *mut T, length: usize, capacity: usize, alloc: A, ) -> Vec<T, A>

### Description
Creates a `Vec<T, A>` directly from a pointer, a length, a capacity, and an allocator.
```

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

### TryConv Implementation

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EncApRepPart.html

Provides a method for attempting conversions that may fail.

```APIDOC
## fn try_conv<T>(self) -> Result<T, Self::Error>

### Description
Attempts to convert `self` into `T` using `TryInto<T>`.

### Method
`try_conv`

### Parameters
- `T`: The target type to convert into.

### Returns
A `Result` containing the converted value of type `T` or an error.
```

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

### Get BitVec capacity

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.KerberosFlags.html

The `capacity()` method returns the total number of bits the `BitVec` can store before needing to reallocate.

```rust
use bitvec::prelude::*;

let bv = bitvec![0, 1, 0, 0, 1];
// bv.capacity() would return the capacity here.
```

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

### TryFrom Implementation

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EncApRepPart.html

Provides a method for attempting conversions from another type.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error. `Infallible` indicates that this conversion cannot fail.

### Type Alias
`Error`
```

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

### Description
Performs the conversion from type `U` into `T`.

### Method
`try_from`

### Parameters
- `value`: The value of type `U` to convert.

### Returns
A `Result` containing the converted value of type `T` or an error (which is `Infallible` in this case).
```

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

### TryInto Implementation

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EncApRepPart.html

Provides a method for attempting conversions into another type.

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

### Description
Attempts to convert `self` into `U` using `TryFrom<Self>`.

### Method
`try_into`

### Parameters
- `U`: The target type to convert into.

### Returns
A `Result` containing the converted value of type `U` or an error.
```

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

### TryFrom<BitVec<u8, Msb0>> for GeneralString

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.KerberosString.html

Implementation of `TryFrom` to convert a `BitVec<u8, Msb0>` into a GeneralString.

```APIDOC
## impl TryFrom<BitVec<u8, Msb0>> for GeneralString

### Description
Attempts to convert a `BitVec<u8, Msb0>` into a GeneralString. This conversion may fail if the bit vector does not represent a valid GeneralString.

### Type Alias
- `Error`: `PermittedAlphabetError` - The type returned in the event of a conversion error.

### Method
`try_from`

### Parameters
- `string` (`BitVec<u8, Msb0>`) - The bit vector to convert.

### Returns
- `Result<GeneralString, PermittedAlphabetError>` - Ok(GeneralString) on success, Err(PermittedAlphabetError) on failure.
```

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

### TryInto Implementation

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KrbCred.html

Provides a method for attempting conversions that may fail, using `TryFrom`.

```APIDOC
## TryInto<U> for T

### Description
Provides a method for attempting conversions that may fail, using `TryFrom`.

### Note
This implementation relies on the `TryFrom<T>` trait being implemented for `U`.
```

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

### Extend Vec from Range (From Index)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.MethodData.html

Clones elements from a specified range (starting from an index to the end) and appends them to the Vec.

```rust
let mut characters = vec!['a', 'b', 'c', 'd', 'e'];
characters.extend_from_within(2..);
assert_eq!(characters, ['a', 'b', 'c', 'd', 'e', 'c', 'd', 'e']);
```

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

### KdcOptions Methods

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KdcOptions.html

Provides an overview of the methods available for the KdcOptions struct, including cloning, decoding, encoding, hashing, and comparison operations.

```APIDOC
## KdcOptions

### Description
Represents options for a Key Distribution Center (KDC).

### Methods

#### `clone(&self) -> KdcOptions`
Returns a duplicate of the value.

#### `clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

#### `decode<D>(decoder: &mut D) -> Result<Self, <D as Decoder>::Error>`
Decode this value from a given ASN.1 decoder.

#### `decode_with_tag<D>(decoder: &mut D, tag: Tag) -> Result<Self, <D as Decoder>::Error>`
Decode this value implicitly tagged with `tag` from a given ASN.1 decoder.

#### `decode_with_constraints<D>(decoder: &mut D, constraints: Constraints<'_>) -> Result<Self, <D as Decoder>::Error>`
Decode this value with constraints from a given ASN.1 decoder.

#### `decode_with_tag_and_constraints<D, 'constraints>(decoder: &mut D, tag: Tag, constraints: Constraints<'constraints>) -> Result<KdcOptions, <D as Decoder>::Error>`
Decode this value with tag and constraints from a given ASN.1 decoder.

#### `encode<E>(&self, encoder: &mut E) -> Result<(), <E as Encoder>::Error>`
Encodes `self`’s data into the given `Encoder`.

#### `encode_with_tag<E>(&self, encoder: &mut E, tag: Tag) -> Result<(), <E as Encoder>::Error>`
Encode this value with `tag` into the given `Encoder`.

#### `encode_with_constraints<E>(&self, encoder: &mut E, constraints: Constraints<'_>) -> Result<(), <E as Encoder>::Error>`
Encode this value with constraints into the given `Encoder`.

#### `encode_with_tag_and_constraints<EN, 'constraints>(&self, encoder: &mut EN, tag: Tag, constraints: Constraints<'constraints>) -> Result<(), <EN as Encoder>::Error>`
Encode this value with tag and constraints into the given `Encoder`.

#### `hash<__H>(&self, state: &mut __H)`
Feeds this value into the given `Hasher`.

#### `hash_slice<H>(data: &[Self], state: &mut H)`
Feeds a slice of this type into the given `Hasher`.

#### `cmp(&self, other: &KdcOptions) -> Ordering`
This method returns an `Ordering` between `self` and `other`.

#### `max(self, other: Self) -> Self`
Compares and returns the maximum of two values.

#### `min(self, other: Self) -> Self`
Compares and returns the minimum of two values.

#### `clamp(self, min: Self, max: Self) -> Self`
Restrict a value to a certain interval.

#### `eq(&self, other: &KdcOptions) -> bool`
Tests for `self` and `other` values to be equal, and is used by `==`.

#### `ne(&self, other: &Rhs) -> bool`
Tests for `!=`.

#### `partial_cmp(&self, other: &KdcOptions) -> Option<Ordering>`
This method returns an ordering between `self` and `other` values if one exists.

#### `lt(&self, other: &Rhs) -> bool`
Tests less than (for `self` and `other`) and is used by the `<` operator.

#### `le(&self, other: &Rhs) -> bool`
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

#### `gt(&self, other: &Rhs) -> bool`
Tests greater than (for `self` and `other`) and is used by the `>` operator.

#### `ge(&self, other: &Rhs) -> bool`
Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.

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

#### `type_id(&self) -> TypeId`
Gets the `TypeId` of `self`.

#### `borrow(&self) -> &T`
Immutably borrows from an owned value.

#### `borrow_mut(&mut self) -> &mut T`
Mutably borrows from an owned value.

```

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

### Get Underlying Allocator (Nightly)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.MethodData.html

Retrieves a reference to the allocator used by the vector. This is useful for advanced memory management scenarios.

```rust
let allocator_ref = my_vec.allocator();
```

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

### Get Underlying Allocator Reference (Nightly)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdMandatoryForKdc.html

Returns a reference to the vector's underlying allocator. This is a nightly-only experimental API.

```rust
let allocator_ref = my_vec.allocator();

```

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

### try_with_capacity_in

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AuthorizationData.html

Constructs a new, empty `Vec<T, A>` with at least the specified capacity and allocator. This is a nightly-only experimental API.

```APIDOC
## pub fn try_with_capacity_in( capacity: usize, alloc: A, ) -> Result<Vec<T, A>, TryReserveError>

### Description
Constructs a new, empty `Vec<T, A>` with at least the specified capacity with the provided allocator. The vector will be able to hold at least `capacity` elements without reallocating. This method is allowed to allocate for more elements than `capacity`. If `capacity` is zero, the vector will not allocate.

### Errors
Returns an error if the capacity exceeds `isize::MAX` _bytes_ , or if the allocator reports allocation failure.
```

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

### Vector with Custom Allocator

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.TypedData.html

Demonstrates creating a vector with a custom allocator and reconstructing it from its parts.

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

use std::alloc.System;

let mut v: Vec<i32, System> = Vec::new_in(System);
v.push(-1);
v.push(0);
v.push(1);

let (ptr, len, cap, alloc) = v.into_parts_with_alloc();

let rebuilt = unsafe {
    // We can now make changes to the components, such as
    // transmuting the raw pointer to a compatible type.
    let ptr = ptr.cast::<u32>();

    Vec::from_parts_in(ptr, len, cap, alloc)
};
assert_eq!(rebuilt, [4294967295, 0, 1]);

```

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

### TryConv Methods

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KdcOptions.html

Provides methods for attempting conversions between types using `TryInto`.

```APIDOC
## try_conv

### Description
Attempts to convert `self` into `T` using `TryInto<T>`.

### Signature
`fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>`
```

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

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

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdMandatoryForKdc.html

Converts a `VecDeque<T>` into a `Vec<T>`. This conversion is O(1) if the deque's internal buffer is contiguous and starts at the beginning of the allocation.

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

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

### CloneToUninit

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EncAsRepPart.html

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

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

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

### Method
`clone_to_uninit`

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

### Response
None
```

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

### Pushing an element and getting a mutable reference

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Appends an element to the back of a vector and returns a mutable reference to the appended element. This operation takes amortized O(1) time.

```rust
let mut vec = vec![1, 2];
let last = vec.push_mut(3);
assert_eq!(*last, 3);
assert_eq!(vec, [1, 2, 3]);

let last = vec.push_mut(3);
*last += 1;
assert_eq!(vec, [1, 2, 3, 4]);

```

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

### EtypeInfoEntry::fmt_list

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EtypeInfoEntry.html

Formats each item in a sequence for an EtypeInfoEntry instance.

```APIDOC
## fn fmt_list(self) -> FmtList<Self>

### Description
Formats each item in a sequence.

### Method
`fmt_list`

### Returns
- `FmtList<Self>`: A formatter for sequence items.
```

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

### Recycle Vec with Different Types (Example)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Illustrates a compile-time error when attempting to recycle a Vec with incompatible item types (different sizes). This is prevented by the Recyclable bound.

```rust
#![feature(vec_recycle, transmutability)]
let vec: Vec<[u8; 2]> = Vec::new();
let _: Vec<[u8; 1]> = vec.recycle();
```

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

### TryConv Implementation

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KrbSafeBody.html

Provides functionality to attempt conversion into another type.

```APIDOC
## fn try_conv<T>(self) -> Result<T, Self::Error>

### Description
Attempts to convert `self` into `T` using `TryInto<T>`.

### Method
`try_conv`

### Parameters
- `T`: The target type to convert into.

### Response
A `Result` containing the converted value of type `T` or an error if the conversion fails.
```

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

### Accessing spare capacity with spare_capacity_mut

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.EtypeInfo2.html

Demonstrates how to get a mutable slice of the vector's unused capacity. This slice contains `MaybeUninit<T>` elements that can be initialized before marking them as used with `set_len`.

```rust
let mut v = Vec::with_capacity(10);

let uninit = v.spare_capacity_mut();
uninit[0].write(0);
uninit[1].write(1);
uninit[2].write(2);

unsafe {
    v.set_len(3);
}

assert_eq!(&v, &[0, 1, 2]);
```

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

### try_with_capacity_in

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Constructs a new, empty `Vec<T, A>` with at least the specified capacity and the provided allocator. This is a nightly-only experimental API.

```APIDOC
## try_with_capacity_in

### Description
Constructs a new, empty `Vec<T, A>` with at least the specified capacity and the provided allocator. The vector will be able to hold at least `capacity` elements without reallocating. This is a nightly-only experimental API.

### Method
`try_with_capacity_in(capacity: usize, alloc: A) -> Result<Vec<T, A>, TryReserveError>`

### Parameters
- `capacity` (usize): The minimum capacity for the vector.
- `alloc` (A): The allocator to use for the vector.

### Response
- `Result<Vec<T, A>, TryReserveError>`: Ok containing the new vector if successful, or an error if allocation fails or capacity exceeds `isize::MAX` bytes.

### Request Example
```rust
#![feature(allocator_api)]
use std::alloc::System;
let mut vec: Vec<i32, _> = Vec::try_with_capacity_in(10, System).unwrap();
```

### Response Example
```rust
// Ok(Vec<i32, System>) with capacity of at least 10
```
```

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

### Accessing Spare Capacity with spare_capacity_mut

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdMandatoryForKdc.html

Use `spare_capacity_mut` to get a mutable slice of the vector's uninitialized capacity. This allows direct filling of memory before marking it as initialized with `set_len`.

```rust
// Allocate vector big enough for 10 elements.
let mut v = Vec::with_capacity(10);

// Fill in the first 3 elements.
let uninit = v.spare_capacity_mut();
uninit[0].write(0);
uninit[1].write(1);
uninit[2].write(2);

// Mark the first 3 elements of the vector as being initialized.
unsafe {
    v.set_len(3);
}

assert_eq!(&v, &[0, 1, 2]);
```

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

### EtypeInfoEntry::clone_to_uninit

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EtypeInfoEntry.html

Performs copy-assignment from an EtypeInfoEntry instance to uninitialized memory. This is a nightly-only experimental API.

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

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

### Method
`clone_to_uninit`

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

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

### new_in

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AuthorizationData.html

Constructs a new, empty `Vec<T, A>` with the specified allocator. This is a nightly-only experimental API.

```APIDOC
## pub const fn new_in(alloc: A) -> Vec<T, A>

### Description
Constructs a new, empty `Vec<T, A>`. The vector will not allocate until elements are pushed onto it.

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

use std::alloc.System;

let mut vec: Vec<i32, _> = Vec::new_in(System);
```
```

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

### Get Mutable Spare Capacity

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Returns a mutable slice of the remaining spare capacity in a Vec as `MaybeUninit<T>`. This allows filling the vector with data before marking it as initialized using `set_len`.

```rust
let mut v = Vec::with_capacity(10);
let uninit = v.spare_capacity_mut();
uninit[0].write(0);
uninit[1].write(1);
uninit[2].write(2);
unsafe {
    v.set_len(3);
}
assert_eq!(&v, &[0, 1, 2]);
```

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

### as_ptr() - Get Immutable Raw Pointer

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Returns a raw pointer to the vector's buffer. The caller must ensure the vector outlives the pointer and that the memory is not mutated through this pointer.

```APIDOC
## pub const fn as_ptr(&self) -> *const T

### Description
Returns a raw pointer to the vector's buffer, or a dangling raw pointer valid for zero sized reads if the vector didn’t allocate.

The caller must ensure that the vector outlives the pointer this function returns, or else it will end up dangling. Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.
The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an `UnsafeCell`) using this pointer or any pointer derived from it. If you need to mutate the contents of the slice, use `as_mut_ptr`.
This method guarantees that for the purpose of the aliasing model, this method does not materialize a reference to the underlying slice, and thus the returned pointer will remain valid when mixed with other calls to `as_ptr`, `as_mut_ptr`, and `as_non_null`. Note that calling other methods that materialize mutable references to the slice, or mutable references to specific elements you are planning on accessing through this pointer, as well as writing to those elements, may still invalidate this pointer. See the second example below for how this guarantee can be used.

### Examples
```rust
let x = vec![1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(*x_ptr.add(i), 1 << i);
    }
}
```

Due to the aliasing guarantee, the following code is legal:
```rust
unsafe {
    let mut v = vec![0, 1, 2];
    let ptr1 = v.as_ptr();
    let _ = ptr1.read();
    let ptr2 = v.as_mut_ptr().offset(2);
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`
    // because it mutated a different element:
    let _ = ptr1.read();
}
```
```

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

### Recycle Vec with Different Alignments (Example)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Demonstrates a compile-time error when trying to recycle a Vec with item types that have different memory alignments. This is also prevented by the Recyclable bound.

```rust
#![feature(vec_recycle, transmutability)]
let vec: Vec<[u16; 0]> = Vec::new();
let _: Vec<[u8; 0]> = vec.recycle();
```

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

### TryFrom Implementation

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.AsReq.html

Implementation for attempting fallible conversions from one type to another.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error.

### Type Alias
`Error`
```

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

### Description
Performs the conversion from type `U` to type `T`.

### Method
`try_from`

### Parameters
- `value`: The value of type `U` to convert.

### Returns
A `Result` containing the converted value of type `T` or an error.
```

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

### Creating BitVec from a Slice

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.KerberosFlags.html

Shows how to create a BitVec from a slice of memory elements. This copies the slice into a new allocation and spans it entirely.

```rust
use bitvec::prelude::*;

let slice = &[0u8, 1, 2, 3];
let bv = BitVec::<_, Lsb0>::from_slice(slice);
assert_eq!(bv.len(), 32);
```

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

### Decompose Vec<T> into Raw Parts

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Use `into_raw_parts` to get the raw pointer, length, and capacity of a Vec. The caller becomes responsible for managing the memory. Reconstruct the Vec using `from_raw_parts`.

```rust
let v: Vec<i32> = vec![-1, 0, 1];

let (ptr, len, cap) = v.into_raw_parts();

let rebuilt = unsafe {
    // We can now make changes to the components, such as
    // transmuting the raw pointer to a compatible type.
    let ptr = ptr as *mut u32;

    Vec::from_raw_parts(ptr, len, cap)
};
assert_eq!(rebuilt, [4294967295, 0, 1]);
```

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

### Quick Start: Kerberos Client Operations

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/index.html

Demonstrates basic Kerberos client operations including obtaining a Ticket Granting Ticket (TGT) and a service ticket. Requires an asynchronous runtime.

```rust
use krb5_rs::client::KerberosClient;

let client = KerberosClient::new("EXAMPLE.COM", "kdc.example.com:88").await?;
let tgt = client.get_tgt("user", "password").await?;
let ticket = client.get_service_ticket(&tgt, "HTTP/web.example.com").await?;
```

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

### PartialEq Implementation for KerberosTime

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KerberosTime.html

Enables equality comparison for KerberosTime instances.

```APIDOC
### impl PartialEq for KerberosTime

* `eq(&self, other: &KerberosTime) -> bool`: Tests for equality between two KerberosTime instances.
* `ne(&self, other: &Rhs) -> bool`: Tests for inequality.
```

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

### Get NonNull Pointer to Vec Buffer (Nightly)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Returns a NonNull pointer to the vector's buffer. Use this when the vector must outlive the pointer. Modifying the vector may invalidate the pointer.

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

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

unsafe {
    let mut v = vec![0];
    let ptr1 = v.as_non_null();
    ptr1.write(1);
    let ptr2 = v.as_non_null();
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`:
    ptr1.write(3);
}
```

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

### TryFrom::try_from

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.Checksum.html

Performs the conversion.

```APIDOC
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
Source§
```

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

### as_mut_ptr() - Get Mutable Raw Pointer

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Returns a raw mutable pointer to the vector's buffer. The caller must ensure the vector outlives the pointer and handle potential deallocation and aliasing rules.

```APIDOC
## pub const fn as_mut_ptr(&mut self) -> *mut T

### Description
Returns a raw mutable pointer to the vector's buffer, or a dangling raw pointer valid for zero sized reads if the vector didn’t allocate.

The caller must ensure that the vector outlives the pointer this function returns, or else it will end up dangling. Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.
This method guarantees that for the purpose of the aliasing model, this method does not materialize a reference to the underlying slice, and thus the returned pointer will remain valid when mixed with other calls to `as_ptr`, `as_mut_ptr`, and `as_non_null`. Note that calling other methods that materialize references to the slice, or references to specific elements you are planning on accessing through this pointer, may still invalidate this pointer. See the second example below for how this guarantee can be used.
The method also guarantees that, as long as `T` is not zero-sized and the capacity is nonzero, the pointer may be passed into `dealloc` with a layout of `Layout::array::<T>(capacity)` in order to deallocate the backing memory. If this is done, be careful not to run the destructor of the `Vec`, as dropping it will result in double-frees. Wrapping the `Vec` in a `ManuallyDrop` is the typical way to achieve this.

### Examples
```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]);
```

Due to the aliasing guarantee, the following code is legal:
```rust
unsafe {
    let mut v = vec![0];
    let ptr1 = v.as_mut_ptr();
    ptr1.write(1);
    let ptr2 = v.as_mut_ptr();
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`:
    ptr1.write(3);
}
```

Deallocating a vector using `Box` (which uses `dealloc` internally):
```rust
use std::mem::{ManuallyDrop, MaybeUninit};

let mut v = ManuallyDrop::new(vec![0, 1, 2]);
let ptr = v.as_mut_ptr();
let capacity = v.capacity();
let slice_ptr: *mut [MaybeUninit<i32>] =
    std::ptr::slice_from_raw_parts_mut(ptr.cast(), capacity);
drop(unsafe { Box::from_raw(slice_ptr) });
```
```

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

### TryConv Method

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.AsReq.html

Method for attempting a fallible conversion.

```APIDOC
## fn try_conv<T>(self) -> Result<T, Self::Error>

### Description
Attempts to convert `self` into `T` using `TryInto<T>`.

### Method
`try_conv`

### Parameters
- `T`: The target type for the conversion.

### Returns
A `Result` containing the converted value of type `T` or an error.
```

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

### Deconstruct and Reconstruct Vec with Allocator

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Use `into_raw_parts_with_alloc` to get the raw parts of a Vec, modify the memory, and then reconstruct the Vec using `from_raw_parts_in`. Ensure all safety invariants are upheld when manually manipulating the memory.

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

use std::alloc::System;

use std::ptr;

let mut v = Vec::with_capacity_in(3, System);
v.push(1);
v.push(2);
v.push(3);

// Deconstruct the vector into parts.
let (p, len, cap, alloc) = v.into_raw_parts_with_alloc();

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_in(p, len, cap, alloc.clone());
    assert_eq!(rebuilt, [4, 5, 6]);
}
```

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

### TryFrom Implementation

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KrbCred.html

Provides a method for infallible conversions from one type to another.

```APIDOC
## TryFrom<U> for T

### Description
Provides a method for infallible conversions from one type to another.

### Type Alias
`type Error = Infallible`

### `try_from` Method

#### Description
Performs the conversion.

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

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

### EtypeInfoEntry::fmt_binary

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.EtypeInfoEntry.html

Formats an EtypeInfoEntry instance using its `Binary` implementation when `Debug`-formatted.

```APIDOC
## fn fmt_binary(self) -> FmtBinary<Self>

### Description
Causes `self` to use its `Binary` implementation when `Debug`-formatted.

### Method
`fmt_binary`

### Returns
- `FmtBinary<Self>`: A formatter for binary representation.
```

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

### Try Reserve Capacity in Vec

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdIfRelevant.html

Provides an example of using `try_reserve` to attempt to reserve capacity, returning a `Result` that indicates success or a `TryReserveError`. This is useful for operations where memory allocation failure should be handled gracefully.

```rust
use std::collections::TryReserveError;

fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> {
    let mut output = Vec::new();

    // Pre-reserve the memory, exiting if we can't
    output.try_reserve(data.len())?;

    // Now we know this can't OOM in the middle of our complex work
    output.extend(data.iter().map(|&val| {
        val * 2 + 5 // very complicated
    }));

    Ok(output)
}
```

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

### Hash Implementation for KerberosTime

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/struct.KerberosTime.html

Allows hashing KerberosTime instances.

```APIDOC
### impl Hash for KerberosTime

* `hash<__H>(&self, state: &mut __H)`: Feeds this value into the given hasher.
* `hash_slice<H>(data: &[Self], state: &mut H)`: Feeds a slice of this type into the given hasher.
```

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

### Get NonNull Pointer to Vector Buffer (Nightly)

Source: https://docs.rs/krb5-rs/0.1.0/krb5_rs/types/type.AdMandatoryForKdc.html

Returns a NonNull pointer to the vector's buffer. The caller must ensure the vector outlives the pointer. Modifying the vector may invalidate the pointer due to reallocation.

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

```

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

unsafe {
    let mut v = vec![0];
    let ptr1 = v.as_non_null();
    ptr1.write(1);
    let ptr2 = v.as_non_null();
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`:
    ptr1.write(3);
}

```
Tokens:
Raw