Enumset

https://docs.rs/enumset/1.1.13/
Admin
A Rust library for defining enums that can be used in compact bit sets, supporting arbitrarily large...
Tokens:79,680
Snippets:643
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### FFI Safety Example with EnumSet

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Demonstrates how to use EnumSet safely across FFI boundaries by specifying a primitive integer type with the `repr` attribute. Ensure that any bits not corresponding to an enum variant are zero when receiving an EnumSet via FFI.

```rust
extern "C" {
    // This function is written in C like:
    // uint32_t some_foreign_function(uint32_t set) { … }
    fn some_foreign_function(set: EnumSet<MyEnum>) -> EnumSet<MyEnum>;
}

#[derive(Debug, EnumSetType)]
#[enumset(repr = "u32")]
enum MyEnum { A, B, C }

let set: EnumSet<MyEnum> = enum_set!(MyEnum::A | MyEnum::C);

let new_set: EnumSet<MyEnum> = unsafe { some_foreign_function(set) };
assert_eq!(new_set, enum_set!(MyEnum::C));
```

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

### Compile-time EnumSet Union Example

Source: https://docs.rs/enumset/1.1.13/enumset/macro.enum_set_union.html

Demonstrates computing a const EnumSet union using the enum_set_union macro. This is intended for const contexts.

```rust
const CONST_SET: EnumSet<Enum> = enum_set_union!(Enum::A, Enum::B);
assert_eq!(CONST_SET, Enum::A | Enum::B);
```

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

### Create an empty MixedEnumSet

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

Use `new()` or `empty()` to create an empty MixedEnumSet. This is the starting point for building a set.

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

```rust
pub const fn empty() -> Self
```

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

### EnumSet Symmetric Difference Macro Example

Source: https://docs.rs/enumset/1.1.13/src/enumset/macros.rs.html

Demonstrates the compile-time computation of the symmetric difference between multiple enum sets. This is useful for const contexts where direct operator usage is not possible.

```rust
# use enumset::*;
# #[derive(EnumSetType, Debug)] enum Enum { A, B, C, D }
const SET_A: EnumSet<Enum> = enum_set!(Enum::A | Enum::B | Enum::D);
const SET_B: EnumSet<Enum> = enum_set!(Enum::B | Enum::C);
const CONST_SET: EnumSet<Enum> = enum_set_symmetric_difference!(SET_A, SET_B);
assert_eq!(CONST_SET, Enum::A | Enum::C | Enum::D);
```

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

### Compile-time EnumSet Complement Example

Source: https://docs.rs/enumset/1.1.13/enumset/macro.enum_set_complement.html

Demonstrates using enum_set_complement to compute the complement of an EnumSet in a const context. Ensure EnumSetType is derived for the enum.

```rust
#[derive(EnumSetType, Debug)]
enum Enum { A, B, C, D }

const SET: EnumSet<Enum> = enum_set!(Enum::B | Enum::C);
const CONST_SET: EnumSet<Enum> = enum_set_complement!(SET);
assert_eq!(CONST_SET, Enum::A | Enum::D);
```

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

### Compile-time Symmetric Difference Example

Source: https://docs.rs/enumset/1.1.13/enumset/macro.enum_set_symmetric_difference.html

Demonstrates computing the symmetric difference of two EnumSet constants at compile time using the enum_set_symmetric_difference macro. Ensure variants are of the same type.

```rust
const SET_A: EnumSet<Enum> = enum_set!(Enum::A | Enum::B | Enum::D);
const SET_B: EnumSet<Enum> = enum_set!(Enum::B | Enum::C);
const CONST_SET: EnumSet<Enum> = enum_set_symmetric_difference!(SET_A, SET_B);
assert_eq!(CONST_SET, Enum::A | Enum::C | Enum::D);
```

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

### Compile-time EnumSet Intersection Example

Source: https://docs.rs/enumset/1.1.13/enumset/macro.enum_set_intersection.html

Demonstrates how to use enum_set_intersection to compute the intersection of two EnumSet constants at compile time. This is useful for optimizing constant data structures.

```rust
const SET_A: EnumSet<Enum> = enum_set!(Enum::A | Enum::B);
const SET_B: EnumSet<Enum> = enum_set!(Enum::B | Enum::C);
const CONST_SET: EnumSet<Enum> = enum_set_intersection!(SET_A, SET_B);
assert_eq!(CONST_SET, Enum::B);
```

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

### type_id

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

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

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

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

### Method
`type_id`

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

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

### Initialize ArrayIter

Source: https://docs.rs/enumset/1.1.13/src/enumset/repr/array.rs.html

Creates a new `ArrayIter` from an `ArrayRepr`. Initializes internal state for forward and backward iteration.

```rust
fn new(array: ArrayRepr<N>) -> Self {
        let mut new = [PrimitiveIter(0); N];
        for i in 0..N {
            new[i] = PrimitiveIter(array.0[i])
        }
        ArrayIter { data: new, done: false, idx_f: 0, idx_r: N - 1 }
    }
```

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

### Getting the Size and Emptiness of an EnumSet

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Returns the number of elements currently in the EnumSet and checks if the set is empty.

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

```rust
pub fn is_empty(&self) -> bool
```

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

### Get trailing zeros count

Source: https://docs.rs/enumset/1.1.13/src/enumset/repr/primitive.rs.html

Calculates the number of trailing zero bits in the binary representation of the primitive type.

```rust
fn trailing_zeros(&self) -> u32 {
    (*self).trailing_zeros()
}
```

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

### Creating a Const EnumSet

Source: https://docs.rs/enumset/1.1.13/enumset/macro.enum_set.html

Demonstrates how to use the enum_set macro to initialize a constant EnumSet. This is the primary use case for the macro, enabling EnumSet creation in const contexts.

```rust
const CONST_SET: EnumSet<Enum> = enum_set!(Enum::A | Enum::B);
assert_eq!(CONST_SET, Enum::A | Enum::B);
```

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

### Get leading zeros count

Source: https://docs.rs/enumset/1.1.13/src/enumset/repr/primitive.rs.html

Calculates the number of leading zero bits in the binary representation of the primitive type.

```rust
fn leading_zeros(&self) -> u32 {
    (*self).leading_zeros()
}
```

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

### take

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSetIter.html

Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Parameters
- **n**: `usize` - The maximum number of elements to yield.
```

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

### ArrayIter size hint

Source: https://docs.rs/enumset/1.1.13/src/enumset/repr/array.rs.html

Provides a size hint for the `ArrayIter`, calculating the exact number of remaining items.

```rust
fn size_hint(&self) -> (usize, Option<usize>) {
        let mut sum = 0;
        for i in self.idx_f..self.idx_r + 1 {
            sum += self.data[i].0.count_ones() as usize;
        }
        (sum, Some(sum))
    }
```

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

### Blanket Implementations

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Provides documentation for blanket implementations applicable to various types, including EnumSet.

```APIDOC
### impl<T> Any for T
where T: 'static + ?Sized,
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

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

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

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

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

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

### impl<T> ToOwned for T
where T: Clone,
#### type Owned = T
#### fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning.
#### fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning.

### impl<T> ToString for T
where T: Display + ?Sized,
#### fn to_string(&self) -> String
Converts the given value to a `String`.

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

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
#### type Error = <U as TryFrom<T>>::Error
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.

### impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,
```

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

### Get Underlying Representation (as_repr)

Source: https://docs.rs/enumset/1.1.13/src/enumset/impl_set_mixed.rs.html

Returns the raw underlying representation of the MixedEnumSet. This operation is zero-cost and does not panic or truncate bits.

```rust
/// Returns a `T::Repr` representing the elements of this set.
///
/// Unlike the other `as_*` methods, this method is zero-cost and guaranteed not to fail,
/// panic or truncate any bits.
#[inline(always)]
pub const fn as_repr(&self) -> <T as EnumSetTypeWithRepr>::Repr {
    self.repr
}
```

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

### format

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

Writes the defmt representation of `self` to `fmt`. Available on crate feature `defmt` only.

```APIDOC
## fn format(&self, f: Formatter<'_>)

### Description
Writes the defmt representation of `self` to `fmt`. This method is available only when the `defmt` crate feature is enabled.

### Method
(Not applicable, this is a Rust method)

### Parameters
* **f** (Formatter<'_>) - The formatter to write the defmt representation to.
```

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

### clone_to_uninit

Source: https://docs.rs/enumset/1.1.13/enumset/set/enum.MixedValue.html

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

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

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`unsafe fn`

### Parameters
#### Path Parameters
- **dest** (*mut u8) - Required - The destination pointer to copy to.

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

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

### Get the number of elements in a MixedEnumSet

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

The `len()` method returns the current number of elements in the set. This is a standard set operation for determining its size.

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

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

### Try creating from a u64 array

Source: https://docs.rs/enumset/1.1.13/src/enumset/repr/primitive.rs.html

Safely attempts to construct a primitive type from a fixed-size array of u64. Returns `None` if the array content is invalid for the target type.

```rust
fn try_from_u64_array<const O: usize>(v: [u64; O]) -> Option<Self> {
    if O == 0 {
        Some(0)
    } else if O == 1 {
        Self::try_from_u64(v[0])
    } else {
        if $preferred_array_len == 1 && v[1] != 0 {
            return None;
        }
        for i in 2..O {
            if v[i] != 0 {
                return None;
            }
        }
        Self::try_from_u128(v[0] as u128 | ((v[1] as u128) << 64))
    }
}
```

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

### Get all valid variants in a MixedEnumSet

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

The `all()` function returns a MixedEnumSet containing all valid variants of the enum. This is useful for initializing a set with all possible values.

```rust
pub const fn all() -> Self
```

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

### rfold Method for DoubleEndedIterator

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSetIter.html

Reduces the iterator's elements to a single value, starting from the back. This method is part of the DoubleEndedIterator trait implementation.

```rust
fn rfold<B, F>(self, init: B, f: F) -> B
where Self: Sized, F: FnMut(B, Self::Item) -> B
```

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

### Clone Implementation for EnumSetIter

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSetIter.html

Demonstrates how to clone an EnumSetIter. This is useful when you need to iterate over the same set multiple times or from different points.

```rust
impl<T: Clone + EnumSetType> Clone for EnumSetIter<T>
where T::Repr: Clone,
{
    fn clone(&self) -> EnumSetIter<T> {
        // ... implementation details ...
    }

    fn clone_from(&mut self, source: &Self) {
        // ... implementation details ...
    }
}
```

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

### partition

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSetIter.html

Consumes an iterator, creating two collections from it.

```APIDOC
## fn partition<B, F>(self, f: F) -> (B, B)

### Description
Consumes an iterator, creating two collections from it.

### Parameters
- **f**: `F` - A closure that takes a reference to an item and returns `true` if the item should be placed in the first collection, `false` otherwise.

### Type Parameters
- **B**: The type of the collections, which must implement `Default` and `Extend<Self::Item>`.
- **F**: `FnMut(&Self::Item) -> bool`

### Returns
`(B, B)` - A tuple containing two collections: the first with items for which the predicate returned `true`, and the second with items for which it returned `false`.
```

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

### Get the number of valid variants

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

The `variant_count()` function returns the total number of valid variants for the enum type. This can be used to understand the capacity of the set.

```rust
pub const fn variant_count() -> u32
```

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

### Type error example for mixed_enum_set

Source: https://docs.rs/enumset/1.1.13/enumset/macro.mixed_enum_set.html

Demonstrates a compile-time type error when attempting to mix enum variants of different types within the `mixed_enum_set!` macro.

```rust
let type_error = enum_set!(Enum::A | Enum2::B);
```

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

### MixedEnumSet Initialization Methods

Source: https://docs.rs/enumset/1.1.13/src/enumset/impl_set_mixed.rs.html

Provides methods to create an empty MixedEnumSet or a set containing all valid variants.

```Rust
impl<T: EnumSetTypeWithRepr> MixedEnumSet<T> {
    const EMPTY_REPR: Self = MixedEnumSet { repr: <T as EnumSetTypePrivate>::Repr::EMPTY };
    const ALL_REPR: Self = MixedEnumSet { repr: T::ALL_BITS };

    /// Creates an empty `MixedEnumSet`.
    #[inline(always)]
    pub const fn new() -> Self {
        Self::EMPTY_REPR
    }

    /// Creates an empty `MixedEnumSet`.
    ///
    /// This is an alias for [`MixedEnumSet::new`].
    #[inline(always)]
    pub const fn empty() -> Self {
        Self::EMPTY_REPR
    }

    /// Returns a `MixedEnumSet` containing all valid variants of the enum.
    #[inline(always)]
    pub const fn all() -> Self {
        Self::ALL_REPR
    }

    /// The number of valid variants that this type can contain.
    #[inline(always)]
    pub const fn variant_count() -> u32 {
        T::VARIANT_COUNT
    }

    set_common_methods!(T, <T as EnumSetTypePrivate>::Repr, impl Into<Self>);

    /// Returns a set containing all enum variants not in this set.
    ///
    /// This method clears any unknown bits already existing in the set.
    #[inline(always)]
    pub fn complement(&self) -> Self {
        Self { repr: !self.repr & T::ALL_BITS }
    }

    /// Returns a set containing all bits not in this set.
    ///
    /// This method sets any unknown bits not already existing in the set.
    #[inline(always)]
    pub fn full_complement(&self) -> Self {
        Self { repr: !self.repr }
    }

    /// Returns the number of elements in this set, excluding unknown bits.
    #[inline(always)]
    pub fn valid_len(&self) -> usize {
        (self.repr & T::ALL_BITS).count_ones() as usize
    }
}
```

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

### from_slice

Source: https://docs.rs/enumset/1.1.13/src/enumset/impl_set.rs.html

Constructs a bitset from a `&[u64]`. Panics if invalid bits are present.

```APIDOC
## from_slice(v: &[u64]) -> Self

### Description
Constructs a bitset from a slice of unsigned 64-bit integers. This method will panic if any bit in the slice does not correspond to an enum variant of `T`.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **v** (&[u64]) - Required - A slice of unsigned 64-bit integers representing the bits.

### Request Example
```json
{
  "v": [1, 2, 3]
}
```

### Response
#### Success Response (200)
- **Self** - The constructed EnumSet instance.

#### Response Example
```json
{
  "repr": "..."
}
```
```

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

### Try creating from a u64 slice

Source: https://docs.rs/enumset/1.1.13/src/enumset/repr/primitive.rs.html

Safely attempts to construct a primitive type from a slice of u64. Returns `None` if the slice content is invalid or cannot be represented.

```rust
fn try_from_u64_slice(v: &[u64]) -> Option<Self> {
    if v.len() == 0 {
        Some(0)
    } else if v.len() == 1 {
        Self::try_from_u64(v[0])
    } else {
        for i in 2..v.len() {
            if v[i] != 0 {
                return None;
            }
        }
        Self::try_from_u128(v[0] as u128 | ((v[1] as u128) << 64))
    }
}
```

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

### by_ref

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSetIter.html

Creates a “by reference” adapter for this instance of `Iterator`.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Iterator`.
```

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

### Get the bit index for an enum variant

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

The `bit_index()` function returns the specific bit position for a given enum variant. This is crucial for understanding how variants map to bits in the underlying representation.

```rust
pub fn bit_index(t: T) -> u32
```

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

### clone_to_uninit

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API and part of the `CloneToUninit` trait implementation.

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

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit`

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

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

### Get the number of valid elements in a MixedEnumSet

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

The `valid_len()` method returns the count of elements that correspond to valid enum variants, excluding any unknown bits. This provides a count of only the recognized enum members.

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

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

### partition

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSetIter.html

Consumes an iterator and creates two collections based on a predicate function.

```APIDOC
## fn partition<B, F>(self, f: F) -> (B, B)

### Description
Consumes an iterator, creating two collections from it based on a predicate.

### Method
`partition`

### Parameters
- `f`: A closure that takes an item and returns a boolean. Items for which the closure returns `true` go into the first collection, and others into the second.

### Returns
A tuple containing two collections (`B`), where `B` implements `Default` and `Extend<Self::Item>`.
```

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

### Sum Implementations for EnumSet

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Demonstrates how to sum elements into an EnumSet or MixedEnumSet using iterators.

```APIDOC
## fn sum<I: Iterator<Item = &'a T>>(iter: I) -> Self

### Description
Takes an iterator and generates `Self` from the elements by “summing up” the items.

### Method
Sum

### Parameters
- **iter**: I - An iterator yielding elements of type `&'a T`.

### Returns
- Self: A new `EnumSet` instance containing the summed elements.
```

```APIDOC
## fn sum<I: Iterator<Item = EnumSet<T>>>(iter: I) -> Self

### Description
Takes an iterator and generates `Self` (MixedEnumSet) from the elements by “summing up” the items.

### Method
Sum

### Parameters
- **iter**: I - An iterator yielding `EnumSet<T>` instances.

### Returns
- Self: A new `MixedEnumSet<T>` instance containing the summed elements.
```

```APIDOC
## fn sum<I: Iterator<Item = T>>(iter: I) -> Self

### Description
Takes an iterator and generates `Self` (EnumSet) from the elements by “summing up” the items.

### Method
Sum

### Parameters
- **iter**: I - An iterator yielding elements of type `T`.

### Returns
- Self: A new `EnumSet<T>` instance containing the summed elements.
```

```APIDOC
## fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

### Description
Takes an iterator and generates `Self` (EnumSet) from the elements by “summing up” the items.

### Method
Sum

### Parameters
- **iter**: I - An iterator yielding `EnumSet<T>` instances.

### Returns
- Self: A new `EnumSet<T>` instance containing the summed elements.
```

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

### product

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSetIter.html

Iterates over the entire iterator, multiplying all the elements. The element type must implement the `Product` trait.

```APIDOC
## fn product<P>(self) -> P

### Description
Iterates over the entire iterator, multiplying all the elements.

### Type Parameters
- `P`: The type to multiply into, which must implement `Product<Self::Item>`.

### Returns
- `P`: The product of the elements in the iterator.
```

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

### map_windows

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSetIter.html

Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. This is a nightly-only experimental API.

```APIDOC
## fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

### Description
Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`.

### Parameters
- **f**: `F` - A closure that takes a slice representing the window and returns a value.

### Type Parameters
- **F**: The type of the closure.
- **R**: The type of the items returned by the closure.
- **N**: The size of the sliding window.
```

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

### EnumSet Conversions (u64)

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Provides methods for converting an EnumSet to and from a u64. Includes safe, truncated, and unchecked conversions.

```APIDOC
## pub fn as_u64(&self) -> u64

### Description
Returns a `u64` representing the elements of this set. If the underlying bitset will not fit in a `u64`, this method will panic.

### Method
`as_u64`

### Parameters
None

### Response
#### Success Response (u64)
- Returns a `u64` representing the set elements.

## pub fn try_as_u64(&self) -> Option<u64>

### Description
Tries to return a `u64` representing the elements of this set. If the underlying bitset will not fit in a `u64`, this method will return `None`.

### Method
`try_as_u64`

### Parameters
None

### Response
#### Success Response (Option<u64>)
- Returns `Some(u64)` if the conversion is successful, otherwise `None`.

## pub fn as_u64_truncated(&self) -> u64

### Description
Returns a truncated `u64` representing the elements of this set. If the underlying bitset will not fit in a `u64`, this method will truncate any bits that don’t fit.

### Method
`as_u64_truncated`

### Parameters
None

### Response
#### Success Response (u64)
- Returns a `u64` representing the set elements.

## pub fn from_u64(bits: u64) -> Self

### Description
Constructs a bitset from a `u64`. If a bit that doesn’t correspond to an enum variant is set, this method will panic.

### Method
`from_u64`

### Parameters
- **bits** (u64) - The `u64` value to construct the bitset from.

### Response
#### Success Response (Self)
- Returns a new EnumSet instance.

## pub fn try_from_u64(bits: u64) -> Option<Self>

### Description
Attempts to construct a bitset from a `u64`. If a bit that doesn’t correspond to an enum variant is set, this method will return `None`.

### Method
`try_from_u64`

### Parameters
- **bits** (u64) - The `u64` value to attempt to construct the bitset from.

### Response
#### Success Response (Option<Self>)
- Returns `Some(EnumSet)` if the conversion is successful, otherwise `None`.

## pub fn from_u64_truncated(bits: u64) -> Self

### Description
Constructs a bitset from a `u64`, ignoring bits that do not correspond to a variant.

### Method
`from_u64_truncated`

### Parameters
- **bits** (u64) - The `u64` value to construct the bitset from.

### Response
#### Success Response (Self)
- Returns a new EnumSet instance.
```

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

### Try converting to u64, u128, and usize

Source: https://docs.rs/enumset/1.1.13/src/enumset/repr/primitive.rs.html

Safely attempts to convert the current primitive type into u64, u128, or usize. Returns `None` if the conversion would overflow.

```rust
fn try_to_u64(&self) -> Option<u64> {
    (*self).try_into().ok()
}
```

```rust
fn try_to_u128(&self) -> Option<u128> {
    (*self).try_into().ok()
}
```

```rust
fn try_to_usize(&self) -> Option<usize> {
    (*self).try_into().ok()
}
```

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

### Try converting to a u64 array

Source: https://docs.rs/enumset/1.1.13/src/enumset/repr/primitive.rs.html

Safely attempts to convert the primitive type into a fixed-size array of u64. Returns `None` if the conversion is not possible due to the array size or value.

```rust
fn try_to_u64_array<const O: usize>(&self) -> Option<[u64; O]> {
    if O == 0 && *self != 0 {
        None
    } else if O == 1 && hi(*self) != 0 {
        None
    } else {
        Some(self.to_u64_array())
    }
}
```

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

### EnumSet Conversions (Array)

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Methods for converting EnumSet to and from arrays of u64, with safety and truncation options.

```APIDOC
## pub fn as_array<const O: usize>(&self) -> [u64; O]

### Description
Returns a `[u64; O]` representing the elements of this set. If the underlying bitset will not fit in a `[u64; O]`, this method will panic.

## pub fn try_as_array<const O: usize>(&self) -> Option<[u64; O]>

### Description
Returns a `[u64; O]` representing the elements of this set. If the underlying bitset will not fit in a `[u64; O]`, this method will instead return `None`.

## pub fn as_array_truncated<const O: usize>(&self) -> [u64; O]

### Description
Returns a `[u64; O]` representing the elements of this set. If the underlying bitset will not fit in a `[u64; O]`, this method will truncate any bits that don’t fit.

## pub fn from_array<const O: usize>(v: [u64; O]) -> Self

### Description
Constructs a bitset from a `[u64; O]`. If a bit that doesn’t correspond to an enum variant is set, this method will panic.

## pub fn try_from_array<const O: usize>(bits: [u64; O]) -> Option<Self>

### Description
Attempts to construct a bitset from a `[u64; O]`. If a bit that doesn’t correspond to an enum variant is set, this method will return `None`.

## pub fn from_array_truncated<const O: usize>(bits: [u64; O]) -> Self

### Description
Constructs a bitset from a `[u64; O]`, ignoring bits that do not correspond to a variant.

## pub unsafe fn from_array_unchecked<const O: usize>(bits: [u64; O]) -> Self

### Description
Constructs a bitset from a `[u64; O]`, without checking for invalid bits.

### Safety
All bits in the provided parameter `bits` that don’t correspond to an enum variant of `T` must be set to `0`. Behavior is **undefined** if any of these bits are set to `1`.

## pub fn to_vec(&self) -> Vec<u64>

### Description
Available on **crate feature`alloc`** only. Returns a `Vec<u64>` representing the elements of this set.
```

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

### TryInto Implementation for Conversions

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSetIter.html

Provides a `try_into` method for attempting conversions from `T` to `U`, where `U` implements `TryFrom<T>`. The `Error` type is determined by the `TryFrom` implementation.

```rust
impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
```

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

### Display

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Implements the `Display` trait for EnumSet, enabling formatted output for display.

```APIDOC
### impl<T: EnumSetType + Display> Display for EnumSet<T>

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result

### Description
Formats the value using the given formatter.
```

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

### Cloning and Default

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

Provides methods for cloning and creating default instances of MixedEnumSet.

```APIDOC
## impl<T: Clone + EnumSetTypeWithRepr> Clone for MixedEnumSet<T>

### Description
Provides functionality to create a copy of a `MixedEnumSet`.

### Method
`clone`

### Returns
- **MixedEnumSet<T>** - A new `MixedEnumSet` that is a duplicate of the original.
```

```APIDOC
## impl<T: Clone + EnumSetTypeWithRepr> Clone for MixedEnumSet<T>

### Description
Performs copy-assignment from a source `MixedEnumSet` to this instance.

### Method
`clone_from`

### Parameters
#### Path Parameters
- **source** (&Self) - Required - The source `MixedEnumSet` to copy from.
```

```APIDOC
## impl<T: EnumSetTypeWithRepr> Default for MixedEnumSet<T>

### Description
Creates an empty `MixedEnumSet`.

### Method
`default`

### Returns
- **Self** - An empty `MixedEnumSet`.
```

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

### EnumSet Array Construction (Optional)

Source: https://docs.rs/enumset/1.1.13/src/enumset/impl_set.rs.html

Attempts to construct an EnumSet from a `[u64; O]` array, returning `None` if invalid bits are present. Use `from_array` if panicking is acceptable.

```rust
pub fn try_from_array<const O: usize>(bits: [u64; O]) -> Option<Self> {
        let bits = T::Repr::try_from_u64_array::<O>(bits);
        let mask = T::ALL_BITS;
        bits.and_then(|bits| {
            if bits.and_not(mask).is_empty() {
                Some(EnumSet { repr: bits })
            } else {
                None
            }
        })
    }
```

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

### from

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSet.html

Returns the argument unchanged. This is part of the `From<T>` trait implementation.

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

### Description
Returns the argument unchanged.

### Method
`from`

### Parameters
- **t**: The value to be converted.
```

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

### EnumSet Conversions (u64)

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Methods for converting EnumSet to and from u64, with safety and truncation options.

```APIDOC
## pub unsafe fn from_u64_unchecked(bits: u64) -> Self

### Description
Constructs a bitset from a `u64`, without checking for invalid bits.

### Safety
All bits in the provided parameter `bits` that don’t correspond to an enum variant of `T` must be set to `0`. Behavior is **undefined** if any of these bits are set to `1`.

## pub fn as_u128(&self) -> u128

### Description
Returns a `u128` representing the elements of this set. If the underlying bitset will not fit in a `u128`, this method will panic.

## pub fn try_as_u128(&self) -> Option<u128>

### Description
Tries to return a `u128` representing the elements of this set. If the underlying bitset will not fit in a `u128`, this method will return `None`.

## pub fn as_u128_truncated(&self) -> u128

### Description
Returns a truncated `u128` representing the elements of this set. If the underlying bitset will not fit in a `u128`, this method will truncate any bits that don’t fit.

## pub fn from_u128(bits: u128) -> Self

### Description
Constructs a bitset from a `u128`. If a bit that doesn’t correspond to an enum variant is set, this method will panic.

## pub fn try_from_u128(bits: u128) -> Option<Self>

### Description
Attempts to construct a bitset from a `u128`. If a bit that doesn’t correspond to an enum variant is set, this method will return `None`.

## pub fn from_u128_truncated(bits: u128) -> Self

### Description
Constructs a bitset from a `u128`, ignoring bits that do not correspond to a variant.

## pub unsafe fn from_u128_unchecked(bits: u128) -> Self

### Description
Constructs a bitset from a `u128`, without checking for invalid bits.

### Safety
All bits in the provided parameter `bits` that don’t correspond to an enum variant of `T` must be set to `0`. Behavior is **undefined** if any of these bits are set to `1`.

## pub fn as_usize(&self) -> usize

### Description
Returns a `usize` representing the elements of this set. If the underlying bitset will not fit in a `usize`, this method will panic.

## pub fn try_as_usize(&self) -> Option<usize>

### Description
Tries to return a `usize` representing the elements of this set. If the underlying bitset will not fit in a `usize`, this method will return `None`.

## pub fn as_usize_truncated(&self) -> usize

### Description
Returns a truncated `usize` representing the elements of this set. If the underlying bitset will not fit in a `usize`, this method will truncate any bits that don’t fit.

## pub fn from_usize(bits: usize) -> Self

### Description
Constructs a bitset from a `usize`. If a bit that doesn’t correspond to an enum variant is set, this method will panic.

## pub fn try_from_usize(bits: usize) -> Option<Self>

### Description
Attempts to construct a bitset from a `usize`. If a bit that doesn’t correspond to an enum variant is set, this method will return `None`.

## pub fn from_usize_truncated(bits: usize) -> Self

### Description
Constructs a bitset from a `usize`, ignoring bits that do not correspond to a variant.

## pub unsafe fn from_usize_unchecked(bits: usize) -> Self

### Description
Constructs a bitset from a `usize`, without checking for invalid bits.

### Safety
All bits in the provided parameter `bits` that don’t correspond to an enum variant of `T` must be set to `0`. Behavior is **undefined** if any of these bits are set to `1`.
```

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

### try_from

Source: https://docs.rs/enumset/1.1.13/src/enumset/impl_set.rs.html

Attempts to construct a bitset from a primitive integer type (Repr), returning None if invalid bits are set. This method requires the enum to have an `#[enumset(repr = "...")]` annotation.

```APIDOC
## try_from

### Description
Attempts to construct a bitset from a `Repr`, returning `None` if invalid bits are set. This method requires the enum to have an `#[enumset(repr = "...")]` annotation.

### Returns
- `Some(Self)` if the `bits` are valid.
- `None` if any bit that doesn't correspond to an enum variant is set.

### Method
`fn try_from(bits: <T as EnumSetTypeWithRepr>::Repr) -> Option<Self>`
```

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

### from_slice

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Constructs a bitset from a `&[u64]`. Panics if a bit not corresponding to an enum variant is set.

```APIDOC
## pub fn from_slice(v: &[u64]) -> Self

### Description
Constructs a bitset from a `&[u64]`.
If a bit that doesn’t correspond to an enum variant is set, this method will panic.

### Parameters
#### Path Parameters
- **v** (&[u64]) - Required - The slice of u64 to construct the bitset from.

### Response
#### Success Response (Self)
- Returns a new EnumSet instance constructed from the provided slice.
```

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

### EnumSet Array Construction (Panic on Invalid)

Source: https://docs.rs/enumset/1.1.13/src/enumset/impl_set.rs.html

Constructs an EnumSet from a `[u64; O]` array, panicking if invalid bits are present. Use `try_from_array` for a non-panicking version.

```rust
pub fn from_array<const O: usize>(v: [u64; O]) -> Self {
        Self::try_from_array(v).expect("Bitset contains invalid variants.")
    }
```

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

### EnumSet Methods

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

This section details the public methods available for the EnumSet struct, allowing users to create, manipulate, and query enum sets.

```APIDOC
## EnumSet Methods

### `new()`

Creates an empty `EnumSet`.

### `empty()`

Creates an empty `EnumSet`. This is an alias for `EnumSet::new`.

### `all()`

Returns an `EnumSet` containing all valid variants of the enum.

### `bit_width()`

Total number of bits used by this type. Note that the actual amount of space used is rounded up to the next highest integer type (`u8`, `u16`, `u32`, `u64`, or `u128`). This is the same as `EnumSet::variant_count` except in enums with “sparse” variants.

### `variant_count()`

The number of valid variants that this type can contain. This is the same as `EnumSet::bit_width` except in enums with “sparse” variants.

### `only(t: T)`

Returns a set containing a single element.

### `bit_index(t: T)`

Returns the bit a given enum variant is stored in. If this returns `n`, it means the bit is stored in the `n + 1`th least significant bit of the underlying integer, corresponding to a mask of `1 << n`.

### `is_bit_valid(bit: u32)`

Returns whether a given bit is valid for this set.

### `len()`

Returns the number of elements in this set.

### `is_empty()`

Returns `true` if the set contains no elements.

### `clear()`

Removes all elements from the set.

### `contains(value: T)`

Checks whether this set contains a value.
```

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

### try_from_slice

Source: https://docs.rs/enumset/1.1.13/src/enumset/impl_set.rs.html

Attempts to construct a bitset from a `&[u64]`. Returns `None` if invalid bits are present.

```APIDOC
## try_from_slice(bits: &[u64]) -> Option<Self>

### Description
Attempts to construct a bitset from a slice of unsigned 64-bit integers. If any bit in the slice does not correspond to an enum variant of `T`, this method will return `None`. Otherwise, it returns `Some(Self)`.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **bits** (&[u64]) - Required - A slice of unsigned 64-bit integers representing the bits.

### Request Example
```json
{
  "bits": [1, 2, 3]
}
```

### Response
#### Success Response (200)
- **Option<Self>** - `Some(EnumSet)` if the slice is valid, `None` otherwise.

#### Response Example
```json
{
  "repr": "..."
}
```
```

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

### eq_by

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.MixedEnumSetIter.html

Compares elements for equality using a custom equality function. This nightly-only experimental API provides flexibility in defining equality criteria.

```APIDOC
## fn eq_by<I, F>(self, other: I, eq: F) -> bool

### Description
Determines if the elements of this `Iterator` are equal to those of another with respect to the specified equality function.

### Parameters
#### Parameter `other`
- `other`: An `IntoIterator` whose elements will be compared.
#### Closure Parameter `eq`
- `eq`: A closure that takes two elements and returns a `bool` indicating equality.

### Type Parameters
- `I`: The type of the other iterator.
- `F`: The type of the equality closure.

### Returns
- `bool`: `true` if all elements are equal according to the closure, `false` otherwise.
```

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

### inspect

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSetIter.html

Does something with each element of an iterator, passing the value on.

```APIDOC
## fn inspect<F>(self, f: F) -> Inspect<Self, F>

### Description
Does something with each element of an iterator, passing the value on.

### Parameters
- **f**: `F` - A closure that takes a reference to an item.
```

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

### from

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Converts an EnumSet or related types into an EnumSet. Multiple `from` implementations exist for different input types.

```APIDOC
## fn from(value: [T; N]) -> Self

### Description
Converts to this type from the input type.

### Method
`from`

### Parameters
#### Path Parameters
- `value` ([T; N]): The array to convert.
```

```APIDOC
## fn from(value: EnumSet<T>) -> Self

### Description
Converts to this type from the input type.

### Method
`from`

### Parameters
#### Path Parameters
- `value` (EnumSet<T>): The EnumSet to convert.
```

```APIDOC
## fn from(t: T) -> Self

### Description
Converts to this type from the input type.

### Method
`from`

### Parameters
#### Path Parameters
- `t` (T): The value to convert.
```

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

### EnumSet Conversions (u32)

Source: https://docs.rs/enumset/1.1.13/enumset/set/struct.EnumSet.html

Provides methods for converting an EnumSet to and from a u32. Includes safe, truncated, and unchecked conversions.

```APIDOC
## pub fn as_u32(&self) -> u32

### Description
Returns a `u32` representing the elements of this set. If the underlying bitset will not fit in a `u32`, this method will panic.

### Method
`as_u32`

### Parameters
None

### Response
#### Success Response (u32)
- Returns a `u32` representing the set elements.

## pub fn try_as_u32(&self) -> Option<u32>

### Description
Tries to return a `u32` representing the elements of this set. If the underlying bitset will not fit in a `u32`, this method will return `None`.

### Method
`try_as_u32`

### Parameters
None

### Response
#### Success Response (Option<u32>)
- Returns `Some(u32)` if the conversion is successful, otherwise `None`.

## pub fn as_u32_truncated(&self) -> u32

### Description
Returns a truncated `u32` representing the elements of this set. If the underlying bitset will not fit in a `u32`, this method will truncate any bits that don’t fit.

### Method
`as_u32_truncated`

### Parameters
None

### Response
#### Success Response (u32)
- Returns a `u32` representing the set elements.

## pub fn from_u32(bits: u32) -> Self

### Description
Constructs a bitset from a `u32`. If a bit that doesn’t correspond to an enum variant is set, this method will panic.

### Method
`from_u32`

### Parameters
- **bits** (u32) - The `u32` value to construct the bitset from.

### Response
#### Success Response (Self)
- Returns a new EnumSet instance.

## pub fn try_from_u32(bits: u32) -> Option<Self>

### Description
Attempts to construct a bitset from a `u32`. If a bit that doesn’t correspond to an enum variant is set, this method will return `None`.

### Method
`try_from_u32`

### Parameters
- **bits** (u32) - The `u32` value to attempt to construct the bitset from.

### Response
#### Success Response (Option<Self>)
- Returns `Some(EnumSet)` if the conversion is successful, otherwise `None`.

## pub fn from_u32_truncated(bits: u32) -> Self

### Description
Constructs a bitset from a `u32`, ignoring bits that do not correspond to a variant.

### Method
`from_u32_truncated`

### Parameters
- **bits** (u32) - The `u32` value to construct the bitset from.

### Response
#### Success Response (Self)
- Returns a new EnumSet instance.

## pub unsafe fn from_u32_unchecked(bits: u32) -> Self

### Description
Constructs a bitset from a `u32`, without checking for invalid bits.

### Safety
All bits in the provided parameter `bits` that don’t correspond to an enum variant of `T` must be set to `0`. Behavior is **undefined** if any of these bits are set to `1`.

### Method
`from_u32_unchecked`

### Parameters
- **bits** (u32) - The `u32` value to construct the bitset from.

### Response
#### Success Response (Self)
- Returns a new EnumSet instance.
```

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

### EnumSet Initialization Helper

Source: https://docs.rs/enumset/1.1.13/src/enumset/impl_set.rs.html

A helper struct for constant evaluation, used internally for EnumSet operations.

```rust
pub const fn const_only<T>(&self, value: T) -> T {
        value
    }
```
Tokens:
Raw