Octotablet

https://docs.rs/octotablet/0.1.0
Admin
Octotablet is a cross-platform tablet, pad, and stylus API that provides a unified abstraction...
Tokens:87,181
Snippets:1,028
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### ToolEvent Example Usage

Source: https://docs.rs/octotablet/0.1.0/octotablet/events/enum.ToolEvent.html

Illustrates a sequence of ToolEvents, showing how events like Added, In, Pose, Button, Frame, Out, and Removed might occur over time.

```text
-Added
/In
|Pose
\Frame
/Pose
|Button
\Frame
/Pose
|Out
\Frame
-Removed
```

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

### Get Current Backend

Source: https://docs.rs/octotablet/0.1.0/octotablet/struct.Manager.html

Queries the API currently in use by the Manager. This can provide hints about the capabilities and limitations of the underlying hardware interaction.

```rust
pub fn backed(&self) -> Backend
```

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

### Get Wayland Tools

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Returns a slice of the currently managed Wayland tools.

```rust
fn tools(&self) -> &[crate::tool::Tool] {
        &self.state.tools
    }
```

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

### Get Wayland Tablets

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Returns a slice of the currently managed Wayland tablets.

```rust
fn tablets(&self) -> &[crate::tablet::Tablet] {
        &self.state.tablets
    }
```

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

### Cleanup Start of Pump

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Cleans up leftover tasks from the previous pump cycle. This includes clearing events and executing deferred destructors for pads, tablets, and tools.

```rust
fn cleanup_start(&mut self) {
        // Remove last frame's events
        self.events.clear();
        // Exec all the defered destructors
        for destroy in self.destroy_next_frame.drain(..) {
            match destroy {
                ConstructID::Pad(id) => self.pads.retain(|p| HasWlId::id(p) != &id),
                ConstructID::Tablet(id) => self.tablets.retain(|t| HasWlId::id(t) != &id),
                ConstructID::Tool(id) => {
                    self.tools.retain(|t| HasWlId::id(t) != &id);
                    self.frames_in_progress.retain(|f| f.tool != id);
                }
            }
        }
    }
```

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

### Builder::new

Source: https://docs.rs/octotablet/0.1.0/octotablet/builder/struct.Builder.html

Creates a new Builder instance with default settings.

```APIDOC
## Builder::new

### Description
Creates a new `Builder` instance with default settings.

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

### Returns
A new `Builder` instance.
```

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

### type_id

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AxisIter.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`.

### Returns
The `TypeId` of `self`.
```

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

### Building the Manager

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/builder.rs.html

Methods for constructing the `Manager` from different display handle configurations.

```APIDOC
## Building the Manager

### `build_shared<Holder>(self, rwh: &std::sync::Arc<Holder>) -> Result<Manager, BuildError>`

Builds a `Manager` from a shared display handle carrier. The `Arc` is kept alive for the lifetime of the `Manager`.

- **rwh** (&std::sync::Arc<Holder>) - A reference to an `Arc` containing the display handle carrier.

Returns `Ok(Manager)` on success, or `Err(BuildError)` on failure.

### `build_raw(self, rwh: impl raw_window_handle::HasDisplayHandle + raw_window_handle::HasWindowHandle) -> Result<Manager, BuildError>`

Builds a `Manager` from a display handle carrier with an unbound lifetime. This method is `unsafe` because the caller must ensure the display handle remains valid for the lifetime of the returned `Manager`.

- **rwh** (impl `HasDisplayHandle` + `HasWindowHandle`) - The display handle carrier.

Returns `Ok(Manager)` on success, or `Err(BuildError)` on failure.

### Safety

For `build_raw`, the provided display handle carrier must keep the window and display pointers valid as long as the returned `Manager` is alive.
```

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

### take

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AxisIter.html

Creates an iterator that yields the first `n` elements.

```APIDOC
## 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.
```

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

### Get Wayland Pads

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Returns a slice of the currently managed Wayland pads.

```rust
fn pads(&self) -> &[crate::pad::Pad] {
        &self.state.pads
    }
```

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

### Emulate Tool from Mouse Input

Source: https://docs.rs/octotablet/0.1.0/octotablet/builder/struct.Builder.html

Configures the Builder to emulate a tablet and tool from mouse input. This feature relies on the system backend and defaults to true.

```rust
pub fn emulate_tool_from_mouse(self, emulate: bool) -> Self
```

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

### Implement CloneToUninit (Nightly)

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.CircularInfo.html

Nightly-only experimental API for performing copy-assignment from self to uninitialized memory.

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

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

### Get None value for NicheF32

Source: https://docs.rs/octotablet/0.1.0/octotablet/util/struct.NicheF32.html

Returns a NicheF32 representing the None state.

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

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

### Tablet ID Method

Source: https://docs.rs/octotablet/0.1.0/octotablet/tablet/struct.Tablet.html

Provides a method to get an opaque, transient ID for the tablet.

```APIDOC
## impl Tablet

### pub fn id(&self) -> ID

Opaque, transient ID of this tool, assigned arbitrarily by the software. Will not be stable across invocations or even unplugs/replugs!
```

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

### Get Minimum of Two FrameTimestamps

Source: https://docs.rs/octotablet/0.1.0/octotablet/events/struct.FrameTimestamp.html

Compares two FrameTimestamp values and returns the minimum.

```rust
fn min(self, other: Self) -> Self
where Self: Sized,
```

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

### Initialize Builder

Source: https://docs.rs/octotablet/0.1.0/octotablet/builder/struct.Builder.html

Creates a new instance of the Builder with default settings.

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

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

### Get Maximum of Two FrameTimestamps

Source: https://docs.rs/octotablet/0.1.0/octotablet/events/struct.FrameTimestamp.html

Compares two FrameTimestamp values and returns the maximum.

```rust
fn max(self, other: Self) -> Self
where Self: Sized,
```

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

### Builder::emulate_tool_from_mouse()

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/builder.rs.html

Configures whether to emulate a tablet and tool from mouse input. This setting is handled by the system backend and defaults to true.

```rust
pub fn emulate_tool_from_mouse(self, emulate: bool) -> Self {
    Self {
        emulate_tool_from_mouse: emulate,
        ..self
    }
}
```

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

### AvailableAxes Initialization Methods

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AvailableAxes.html

Methods for creating and initializing AvailableAxes bitflags.

```APIDOC
## AvailableAxes Initialization Methods

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

Get a flags value with all bits unset.

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

Get a flags value with all known bits set.

### `pub const fn from_bits(bits: u16) -> Option<Self>`

Convert from a bits value. This method will return `None` if any unknown bits are set.

### `pub const fn from_bits_truncate(bits: u16) -> Self`

Convert from a bits value, unsetting any unknown bits.

### `pub const fn from_bits_retain(bits: u16) -> Self`

Convert from a bits value exactly.

### `pub fn from_name(name: &str) -> Option<Self>`

Get a flags value with the bits of a flag with the given name set. This method will return `None` if `name` is empty or doesn’t correspond to any named flag.
```

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

### Get Manager from Events

Source: https://docs.rs/octotablet/0.1.0/octotablet/events/struct.Events.html

Retrieves a reference to the Manager that owns the devices and events associated with this Events struct.

```rust
pub fn manager(&self) -> &'manager Manager
```

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

### Build Wayland Display Manager

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Constructs a new tablet manager by initializing a Wayland connection and event queue from a foreign display pointer. This function is unsafe due to the requirement that the provided display pointer must remain valid.

```rust
pub(crate) unsafe fn build_wayland_display(
        _: crate::builder::Builder,
        wl_display: *mut (),
    ) -> Manager {
        // Safety - deferred to this fn's contract
        let backend =
            unsafe { wayland_backend::client::Backend::from_foreign_display(wl_display.cast()) };
        let conn = wayland_client::Connection::from_backend(backend);
        let display = conn.display();
        let queue = conn.new_event_queue();
        let qh = queue.handle();
        // Allow the manager impl to sift through and capture extention handles
        display.get_registry(&qh, ());
        Manager {
            _display: display,
            _conn: conn,
            queue,
            _qh: qh,
            state: TabletState::default(),
        }
    }
```

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

### Get Option<f32> from NicheF32

Source: https://docs.rs/octotablet/0.1.0/octotablet/util/struct.NicheF32.html

Retrieves the inner Option<f32> value from NicheF32. If Some, the value is guaranteed not to be NaN.

```rust
pub fn get(self) -> Option<f32>
```

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

### Builder Configuration

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/builder.rs.html

Provides methods to configure the builder before creating a Manager. Includes setting emulation options.

```APIDOC
## Builder Methods

### `new()`

Creates a new `Builder` with default settings.

### `emulate_tool_from_mouse(emulate: bool)`

Sets whether an emulated tablet and tool should be created from mouse input. This functionality is provided by the system backend.

- **emulate** (bool) - `true` to enable, `false` to disable.

Defaults to `true`.

Supported platforms: Windows Ink.
```

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

### DoubleEndedIterator Implementation for AxisIter

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AxisIter.html

Enables iteration from both the front and back of the AxisIter. Use `next_back` to get elements from the end.

```rust
fn next_back(&mut self) -> Option<<Self as Iterator>::Item>
```

```rust
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
```

```rust
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
```

```rust
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,
```

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

```rust
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
where Self: Sized, P: FnMut(&Self::Item) -> bool,
```

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

### Builder::emulate_tool_from_mouse

Source: https://docs.rs/octotablet/0.1.0/octotablet/builder/struct.Builder.html

Sets whether an emulated tablet and tool should be created from mouse input. This functionality is not provided by this crate, but by the system backend. Defaults to `true`.

```APIDOC
## Builder::emulate_tool_from_mouse

### Description
Set whether an emulated tablet and tool should be created from mouse input. This functionality is _not_ provided by this crate, but by the system backend.

Defaults to `true`.

### Method
```rust
pub fn emulate_tool_from_mouse(self, emulate: bool) -> Self
```

### Parameters
- **emulate** (bool) - Description of the emulation setting.

### Returns
A `Builder` instance with the emulation setting configured.
```

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

### ExactSizeIterator Implementation for AxisIter

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AxisIter.html

Provides information about the exact remaining length of the iterator. Use `len` to get the current count.

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

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

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

### Builder::new() - Default Configuration

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/builder.rs.html

Creates a new Builder with default settings. Use this for a standard configuration.

```rust
pub fn new() -> Self {
    Self::default()
}
```

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

### Get FrameTimestamp Epoch

Source: https://docs.rs/octotablet/0.1.0/octotablet/events/struct.FrameTimestamp.html

Retrieves the epoch timestamp for FrameTimestamp. This value is only useful for subtracting from other timestamps and is not a reliable reference point.

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

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

### ToString Implementation for BuildError

Source: https://docs.rs/octotablet/0.1.0/octotablet/builder/enum.BuildError.html

Converts the BuildError enum into a String representation. This is the recommended way to get a human-readable description of the error.

```rust
fn to_string(&self) -> String
```

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

### Wayland Tablet Done Implementation

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Completes the creation of a Wayland Tablet. This implementation always succeeds as no further validation is needed.

```rust
impl HasWlId for Tablet {
    type DoneError = std::convert::Infallible;
    fn done(self) -> Result<Self, Self::DoneError> {
        Ok(self)
    }
    fn new_default(id: ID) -> Self {
        Tablet {
            internal_id: id.into(),
            name: None,
            usb_id: None,
        }
    }
    fn id(&self) -> &ID {
        // Unwrap OK - We only ever create `Wayland` instances, and it's not possible
        // for an externally created instance to get in here.
        self.internal_id.unwrap_wl()
    }
}
```

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

### FullInfo::available

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/axis.rs.html

Returns a bitmask indicating which axes are available on the device.

```APIDOC
## available

### Description
Get a bitmask summary of the available axes.

### Method
`fn available(&self) -> AvailableAxes`

### Parameters
None

### Returns
`AvailableAxes`: A bitmask representing the available axes.
```

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

### Get Available Axes

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.FullInfo.html

Retrieves a bitmask summarizing which axes are supported by the device. This is useful for determining the device's input capabilities.

```rust
pub fn available(&self) -> AvailableAxes
```

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

### Manager::build_wayland_display

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Creates a tablet manager from a given pointer to a wl_display. This function is unsafe as the provided display pointer must remain valid for the lifetime of the returned Manager.

```APIDOC
## Manager::build_wayland_display

### Description
Creates a tablet manager from a given pointer to a `wl_display`. This function is unsafe as the provided display pointer must remain valid for the lifetime of the returned `Manager`.

### Safety
The given display pointer must be valid as long as the returned `Manager` is alive.

### Signature
```rust
pub(crate) unsafe fn build_wayland_display(
    _: crate::builder::Builder,
    wl_display: *mut (),
) -> Manager
```
```

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

### Unsupported Platform Handling

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/builder.rs.html

Provides a fallback for any unhandled or unsupported platform display handles, returning a `BuildError::Unsupported`.

```rust
_ => Err(BuildError::Unsupported),
        
```

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

### Get Available Axes Bitmask

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/axis.rs.html

Generates a bitmask indicating which axes are currently supported by the device. Useful for determining device capabilities at runtime.

```rust
pub fn available(&self) -> AvailableAxes {
        let empty = AvailableAxes::empty();

        self.slider.map_or(empty, |_| AvailableAxes::SLIDER)
        | self.roll.map_or(empty, |_| AvailableAxes::ROLL)
        | self.pressure.map_or(empty, |_| AvailableAxes::PRESSURE)
        | self.button_pressure.map_or(empty, |_| AvailableAxes::BUTTON_PRESSURE)
        | self.tilt.map_or(empty, |_| AvailableAxes::TILT)
        | self.wheel.map_or(empty, |_| AvailableAxes::WHEEL)
        | self.distance.map_or(empty, |_| AvailableAxes::DISTANCE)
        | self.contact_size.map_or(empty, |_| AvailableAxes::CONTACT_SIZE)
    }
```

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

### NicheF32 Trait Implementations

Source: https://docs.rs/octotablet/0.1.0/octotablet/util/struct.NicheF32.html

Details on trait implementations for NicheF32, including Clone, Debug, Default, PartialEq, and PartialOrd.

```APIDOC
## Trait Implementations for NicheF32

### `impl Clone for NicheF32`

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

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

### `impl Debug for NicheF32`

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

### `impl Default for NicheF32`

#### `fn default() -> Self`
Returns the “default value” for a type.

### `impl PartialEq<NicheF32> for f32`

#### `fn eq(&self, other: &NicheF32) -> bool`
Tests for `self` and `other` values to be equal.

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

### `impl PartialEq<f32> for NicheF32`

#### `fn eq(&self, other: &f32) -> bool`
Tests for `self` and `other` values to be equal.

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

### `impl PartialEq for NicheF32`

#### `fn eq(&self, other: &Self) -> bool`
Tests for `self` and `other` values to be equal.

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

### `impl PartialOrd for NicheF32`

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

#### `fn lt(&self, other: &Rhs) -> bool`
Tests less than.

#### `fn le(&self, other: &Rhs) -> bool`
Tests less than or equal to.

#### `fn gt(&self, other: &Rhs) -> bool`
Tests greater than.

#### `fn ge(&self, other: &Rhs) -> bool`
Tests greater than or equal to.

### `impl TryFrom<Option<f32>> for NicheF32`

#### `type Error = NicheF32Error`
The type returned in the event of a conversion error.

#### `fn try_from(value: Option<f32>) -> Result<Self, Self::Error>`
Performs the conversion.

### `impl Copy for NicheF32`

### `impl Eq for NicheF32`
```

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

### Implement Get ID Macro for Tablet

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/tablet.rs.html

This macro is used to implement the `GetID` trait for the `Tablet` struct, allowing it to be identified by its internal ID.

```rust
crate::util::macro_bits::impl_get_id!(ID for Tablet);
```

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

### Get AvailableAxes Flags by Name

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AvailableAxes.html

Retrieves an AvailableAxes flags value by its string name. Returns `None` if the name is empty or does not correspond to a known flag.

```rust
pub fn from_name(name: &str) -> Option<Self>
```

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

### Error::cause Implementation for BuildError (Deprecated)

Source: https://docs.rs/octotablet/0.1.0/octotablet/builder/enum.BuildError.html

Deprecated method for getting the underlying cause of the error. Use `Error::source` instead, which supports downcasting.

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

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

### Compare TouchSource for Equality

Source: https://docs.rs/octotablet/0.1.0/octotablet/pad/enum.TouchSource.html

Shows how to compare two TouchSource values for equality using the PartialEq trait. This is used by the `==` operator.

```rust
fn eq(&self, other: &TouchSource) -> bool
```

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

### Clone Implementation for FullInfo

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.FullInfo.html

Provides methods for duplicating FullInfo values. `clone` creates a new copy, while `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> FullInfo
```

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Error::description Implementation for BuildError (Deprecated)

Source: https://docs.rs/octotablet/0.1.0/octotablet/builder/enum.BuildError.html

Deprecated method for getting a string description of the error. Prefer using the Display implementation or `to_string()` instead.

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

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

### take

Source: https://docs.rs/octotablet/0.1.0/octotablet/events/struct.EventIterator.html

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

```APIDOC
## take

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

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

### Constraints
`where Self: Sized`
```

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

### NicheF32 Methods

Source: https://docs.rs/octotablet/0.1.0/octotablet/util/struct.NicheF32.html

Provides methods for creating, accessing, and converting NicheF32 values.

```APIDOC
## NicheF32

An Option type where NaN is the niche.

### Constants

#### `const NONE: NicheF32`
Represents the None variant of NicheF32.

#### `const ZERO: NicheF32`
Represents the zero value for NicheF32.

### Methods

#### `pub fn new_some(value: f32) -> Option<Self>`
Wrap a non-`NaN` value. Fails with `None` if the value was `NaN`.

#### `pub const fn new_none() -> Self`
Get a `None` niche.

#### `pub fn get(self) -> Option<f32>`
Get the optional value within. If `Some`, guaranteed to not be `NaN`.

#### `pub unsafe fn from_option_unchecked(value: Option<f32>) -> Self`
Create from an `Option`. `Some` and `None` variants will correspond exactly with return value of `self.get()`.

##### Safety
The value must not be `Some(NaN)`.
```

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

### Get Axis Limits

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/axis.rs.html

Retrieves the supported limits for a given axis. Returns `Ok(None)` if the axis is supported but its range is unknown, or `Err(_)` if the axis is not supported.

```rust
pub fn limits(&self, axis: Axis) -> Result<Option<Limits>, UnsupportedAxisError> {
        // TAU.next_down(). That fn is unstable, so here it is hardcoded~!
        let tau_exclusive = f32::from_bits(0x40C9_0FDA);

        match axis {
            // ===== Fixed-range axes:
            // Normalized:
            Axis::Pressure => self
                .pressure
                .map(|_| Some((0.0..=1.0f32).into()))
                .ok_or(UnsupportedAxisError),
            Axis::ButtonPressure => self
                .button_pressure
                .map(|_| Some((0.0..=1.0f32).into()))
                .ok_or(UnsupportedAxisError),
            // Circular:
            Axis::Roll => self
                .roll
                .map(|_| Some((0.0..=tau_exclusive).into()))
                .ok_or(UnsupportedAxisError),
            Axis::Wheel => self
                .wheel
                .map(|_| Some((0.0..=tau_exclusive).into()))
                .ok_or(UnsupportedAxisError),
            // Weird guy:
            Axis::Slider => self
                .slider
                .map(|_| Some((-1.0..=1.0).into()))
                .ok_or(UnsupportedAxisError),
            // ===== Dynamic-range axes:
            Axis::Tilt => self
                .tilt
                .as_ref()
                .map(|a| a.limits)
                .ok_or(UnsupportedAxisError),
            // Normalized or CM
            Axis::Distance => self
                .distance
                .map(LengthInfo::limits)
                .ok_or(UnsupportedAxisError),
            Axis::ContactSize => self
                .contact_size
                .map(LengthInfo::limits)
                .ok_or(UnsupportedAxisError),
        }
    }
}
```

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

### Clone Implementation for NormalizedInfo

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.NormalizedInfo.html

Provides methods for cloning NormalizedInfo instances. Use `clone` for a simple copy and `clone_from` for in-place assignment.

```rust
fn clone(&self) -> NormalizedInfo
```

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Hash Slice of TouchSource

Source: https://docs.rs/octotablet/0.1.0/octotablet/pad/enum.TouchSource.html

Demonstrates how to hash a slice of TouchSource values. This is an efficient way to feed multiple enum instances into a hasher.

```rust
fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher,
      Self: Sized,
```

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

### Iterator Trait Implementation for AxisIter

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AxisIter.html

Provides core iterator functionality for AxisIter, including methods to get the next element, estimate remaining length, and advance the iterator.

```APIDOC
### impl Iterator for AxisIter

#### type Item = Axis

The type of the elements being iterated over.

#### fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

#### fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

#### fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the `n`th element of the iterator.

#### fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

#### fn last(self) -> Option<Self::Item>

Consumes the iterator, returning the last element.

#### fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

Advances the iterator by `n` elements.

#### fn step_by(self, step: usize) -> StepBy<Self>

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

#### fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

Takes two iterators and creates a new iterator over both in sequence.

#### fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

‘Zips up’ two iterators into a single iterator of pairs.

#### fn map<B, F>(self, f: F) -> Map<Self, F>

Takes a closure and creates an iterator which calls that closure on each element.
```

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

### Get or Create Frame in Progress

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Retrieves a mutable reference to a `FrameInProgress` for a given tool, creating a new one if it doesn't exist. Initializes a new frame with default values.

```rust
fn frame_in_progress(&mut self, tool: ID) -> &mut FrameInProgress {
        let pos = self
            .frames_in_progress
            .iter()
            .position(|frame| frame.tool == tool);
        if let Some(pos) = pos {
            &mut self.frames_in_progress[pos]
        } else {
            self.frames_in_progress.push(FrameInProgress {
                tool,
                state_transition: None,
                position: None,
                distance: None,
                pressure: None,
                tilt: None,
                roll: None,
                wheel: None,
                slider: None,
                buttons: smallvec::SmallVec::new(),
            });
            self.frames_in_progress.last_mut().unwrap()
        }
    }
```

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

### Handle Tablet Frame State Transitions (Up/Out)

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Processes the `state_transition` field of a tablet frame to emit `ToolEvent::Up` or `ToolEvent::Out` events. Returns `true` if the frame should be cleared after processing (for `FrameState::Out`).

```rust
let clear = match frame.state_transition {
                Some(FrameState::Up) => {
                    self.events.push(raw_events::Event::Tool {
                        tool: tool.clone(),
                        event: raw_events::ToolEvent::Up,
                    });
                    // We're still In - leave the frame intact.
                    false
                }
                Some(FrameState::Out) => {
                    self.events.push(raw_events::Event::Tool {
                        tool: tool.clone(),
                        event: raw_events::ToolEvent::Out,
                    });
                    // Out - destroy the partial frame afterwards.
                    true
                }
                _ => false,
            };
            // Frame finished. Remove all one-shot components.
            frame.state_transition = None;
            frame.buttons.clear();
            clear
```

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

### EventIterator next() Method

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/events/mod.rs.html

Implements the `Iterator` trait for `EventIterator`. It repeatedly calls `try_next` to get the next event, handling potential errors by printing a debug message and retrying, ensuring infinite loop safety.

```rust
fn next(&mut self) -> Option<Self::Item> {
        let mut maybe_next = self.try_next();
        // Infinite loop safety: the inner iter is a slice iter and thus
        // finite in size. try_next always advances.
        while maybe_next.is_err() {
            // report impl bug.
            #[cfg(debug_assertions)]
            {
                eprintln!("[octotablet] implementation bug! failed to build event, skipping");
            }
            maybe_next = self.try_next();
        }
        // While condition says it's Ok
        // this will be Ok(None) on finish.
        maybe_next.unwrap()
```

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

### Handle WlRegistry Global Events

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Processes global Wayland registry events to bind `wl_seat` and `zwp_tablet_manager_v2` interfaces. It calls `try_acquire_tablet_seat` after binding each, ensuring the tablet seat is acquired as soon as both dependencies are met.

```rust
if let wl_registry::Event::Global {
            name,
            interface,
            version,
        } = event
        {
            match &interface[..] {
                "wl_seat" => {
                    this.seat = Some(registry.bind(name, version, qh, ()));
                    // Need a seat and a tablet manager to bind tablet seat.
                    this.try_acquire_tablet_seat(qh);
                }
                "zwp_tablet_manager_v2" => {
                    this.manager = Some(registry.bind(name, version, qh, ()));
                    // Need a seat and a tablet manager to bind tablet seat.
                    this.try_acquire_tablet_seat(qh);
                }
                _ => (),
            }
        }
```

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

### Clone TouchSource Value

Source: https://docs.rs/octotablet/0.1.0/octotablet/pad/enum.TouchSource.html

Demonstrates how to clone a TouchSource value. This is useful when you need to duplicate the touch source information.

```rust
fn clone(&self) -> TouchSource
```

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

### NicheF32 PartialEq<NicheF32> for f32 Implementation

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/util.rs.html

Implements PartialEq between f32 and NicheF32, allowing direct comparison.

```rust
85impl PartialEq<NicheF32> for f32 {
86    fn eq(&self, other: &NicheF32) -> bool {
87        other == self
88    }
89}
```

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

### Compare TouchSource for Inequality

Source: https://docs.rs/octotablet/0.1.0/octotablet/pad/enum.TouchSource.html

Illustrates how to compare two TouchSource values for inequality. This is used by the `!=` operator and is typically derived from the `eq` implementation.

```rust
fn ne(&self, other: &Rhs) -> bool
```

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

### Manager Initialization

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/builder.rs.html

Initializes the main `Manager` struct with the determined internal platform manager and backing data. This is the final step in the builder process.

```rust
Ok(Manager {
            internal,
            _backing: backing,
        })
```

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

### TryFrom Option<f32> for NicheF32

Source: https://docs.rs/octotablet/0.1.0/octotablet/util/struct.NicheF32.html

Attempts to convert an Option<f32> into a NicheF32. This operation can fail if the input is Some(NaN).

```rust
fn try_from(value: Option<f32>) -> Result<Self, Self::Error>
```

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

### Default Implementation for Info

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.Info.html

Provides the `default` method for the Info struct, returning the default value for the type. This is useful for initializing an Info struct without specific values.

```rust
fn default() -> Info
```

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

### partition

Source: https://docs.rs/octotablet/0.1.0/octotablet/events/struct.EventIterator.html

Consumes an iterator, creating two collections from it.

```APIDOC
## partition

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

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

### Constraints
`where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool`
```

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

### Wayland Tool Done Implementation

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Completes the creation of a Wayland Tool. This implementation always succeeds as no further validation is needed.

```rust
impl HasWlId for Tool {
    type DoneError = std::convert::Infallible;
    fn done(self) -> Result<Self, Self::DoneError> {
        Ok(self)
    }
    fn new_default(id: ID) -> Self {
        Tool {
            internal_id: id.into(),
            name: None,
            hardware_id: None,
            wacom_id: None,
            tool_type: None,
            axes: crate::axis::FullInfo::default(),
        }
    }
    fn id(&self) -> &ID {
        // Unwrap OK - We only ever create `Wayland` instances, and it's not possible
        // for an externally created instance to get in here.
        self.internal_id.unwrap_wl()
    }
}
```

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

### Create NicheF32 from Option<f32>

Source: https://docs.rs/octotablet/0.1.0/octotablet/util/struct.NicheF32.html

Safely creates a NicheF32 from an Option<f32>. Returns None if the input is Some(NaN).

```rust
pub fn new_some(value: f32) -> Option<Self>
```

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

### Borrow and BorrowMut Implementations

Source: https://docs.rs/octotablet/0.1.0/octotablet/tool/struct.ButtonID.html

Shows the implementation of `Borrow` and `BorrowMut` traits for ButtonID, enabling immutable and mutable borrowing respectively.

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
```

```rust
fn borrow(&self) -> &T
```

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
```

```rust
fn borrow_mut(&mut self) -> &mut T
```

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

### Manager::backed

Source: https://docs.rs/octotablet/0.1.0/octotablet/struct.Manager.html

Queries the API currently in use by the Manager, which may provide hints about capabilities and limitations.

```APIDOC
## Manager::backed

### Description
Query the API currently in use. May give some hints as to the capabilities and limitations.

### Method
`pub fn backed(&self) -> Backend`

### Parameters
* `&self`: An immutable reference to the Manager instance.

### Response
* `Backend`: The backend API currently in use.
```

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

### PartialEq Implementation for UsbId

Source: https://docs.rs/octotablet/0.1.0/octotablet/tablet/struct.UsbId.html

Allows for equality comparison between UsbId instances.

```APIDOC
### impl PartialEq for UsbId

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

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

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

### Implement Union for FullInfo

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/axis.rs.html

Combines the information from two `FullInfo` instances, merging details for each supported axis. This is useful for aggregating device state.

```rust
impl Union for FullInfo {
    fn union(&self, other: &Self) -> Self {
        Self {
            position: [
                self.position[0].union(&other.position[0]),
                self.position[1].union(&other.position[1]),
            ],
            slider: self.slider.union(&other.slider),
            roll: self.roll.union(&other.roll),
            pressure: self.pressure.union(&other.pressure),
            button_pressure: self.button_pressure.union(&other.button_pressure),
            tilt: self.tilt.union(&other.tilt),
            wheel: self.wheel.union(&other.wheel),
            distance: self.distance.union(&other.distance),
            contact_size: self.contact_size.union(&other.contact_size),
        }
    }
}
```

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

### try_from Method

Source: https://docs.rs/octotablet/0.1.0/octotablet/tool/enum.Type.html

Performs a conversion from one type to another, returning a Result.

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

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

### StructuralPartialEq Implementation for UsbId

Source: https://docs.rs/octotablet/0.1.0/octotablet/tablet/struct.UsbId.html

Provides structural equality comparison for UsbId.

```APIDOC
### impl StructuralPartialEq for UsbId
```

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

### StructuralPartialEq Implementation for UsbId

Source: https://docs.rs/octotablet/0.1.0/octotablet/tablet/struct.UsbId.html

Enables structural equality comparisons for UsbId, which is useful in certain advanced scenarios.

```rust
impl StructuralPartialEq for UsbId
```

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

### CloneToUninit for Generic Types (Nightly)

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.Limits.html

Performs copy-assignment from `self` to `dest` for generic types `T` that implement `Clone`. This is a nightly-only experimental API.

```rust
impl<T> CloneToUninit for T
where T: Clone,
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### Generic Type Conversions

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.FullInfo.html

Demonstrates generic conversion implementations, including `From<T>` for `T` (identity conversion) and `Into<U>` for `T` (delegating to `U::from(self)`).

```rust
fn from(t: T) -> T
```

```rust
fn into(self) -> U
```

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

### clone_to_uninit

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AxisIter.html

Performs copy-assignment from self to dest. This is a nightly-only experimental API and requires the type to implement Clone.

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

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

### Safety
This function is unsafe and should only be called when `dest` is a valid pointer to uninitialized memory of the correct size.

### Constraints
- `T: Clone`

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

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

### Access Tool Information

Source: https://docs.rs/octotablet/0.1.0/octotablet/struct.Manager.html

Provides access to information about input devices like styluses (tools). Tools report movements, pressure, and have buttons. Hardware reports are updated on each call to `Manager::pump`.

```rust
pub fn tools(&self) -> &[Tool]
```

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

### Handle Wayland Tablet Pad Events

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/pad_impl.rs.html

Implements the `Dispatch` trait for `ZwpTabletPadV2` to handle various pad events. This includes processing constructor databursts like group information and total buttons, as well as interaction events such as button presses and tablet enter/leave.

```rust
impl Dispatch<wl_tablet::zwp_tablet_pad_v2::ZwpTabletPadV2, ()> for TabletState {
    fn event(
        this: &mut Self,
        pad: &wl_tablet::zwp_tablet_pad_v2::ZwpTabletPadV2,
        event: wl_tablet::zwp_tablet_pad_v2::Event,
        (): &(),
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
        use wl_tablet::zwp_tablet_pad_v2::Event;
        #[allow(clippy::match_same_arms)]
        match event {
            // ======= Constructor databurst =========
            Event::Group { pad_group } => {
                let ctor = this.partial_pads.get_or_insert_ctor(pad.id());
                ctor.groups.push(Group::new_default(pad_group.id()));
                // Remember that this group id is associated with this pad.
                this.group_associations.insert(pad_group.id(), pad.id());
            }
            Event::Path { .. } => (),
            Event::Buttons { buttons } => {
                let ctor = this.partial_pads.get_or_insert_ctor(pad.id());
                ctor.total_buttons = buttons;
            }
            Event::Done => {
                let pad_id = pad.id();
                if let Some(Ok(pad)) = this.partial_pads.done(&pad_id) {
                    this.pads.push(pad);
                    this.events.push(raw_events::Event::Pad {
                        pad: pad_id,
                        event: raw_events::PadEvent::Added,
                    });
                }
            }
            Event::Removed => {
                this.destroy_pad(pad.id());
                this.events.push(raw_events::Event::Pad {
                    pad: pad.id(),
                    event: raw_events::PadEvent::Removed,
                });
            }
            // ======== Interaction data =========
            Event::Button {
                button,
                state,
                time: _, //use me!
            } => {
                let pressed = matches!(
                    state,
                    wayland_client::WEnum::Value(
                        wl_tablet::zwp_tablet_pad_v2::ButtonState::Pressed
                    )
                );
                // Send event
                this.events.push(raw_events::Event::Pad {
                    pad: pad.id(),
                    event: raw_events::PadEvent::Button {
                        button_idx: button,
                        pressed,
                    },
                });
            }
            Event::Enter { tablet, .. } => {
                this.events.push(raw_events::Event::Pad {
                    pad: pad.id(),
                    event: raw_events::PadEvent::Enter {
                        tablet: tablet.id(),
                    },
                });
            }
            Event::Leave { .. } => {
                this.events.push(raw_events::Event::Pad {
                    pad: pad.id(),
                    event: raw_events::PadEvent::Exit,
                });
            }
            // ne
            _ => (),
        }
    }
    wayland_client::event_created_child!(
        TabletState,
        wl_tablet::zwp_tablet_pad_v2::ZwpTabletPadV2,
        [
            wl_tablet::zwp_tablet_pad_v2::EVT_GROUP_OPCODE => (wl_tablet::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2, ())
        ]
    );
}
```

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

### CloneToUninit for T

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AvailableAxes.html

Performs copy-assignment from self to a destination in uninitialized memory.

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

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

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

### Any for T

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AvailableAxes.html

Provides runtime type information for any type T.

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

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

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

### Create and Emit Tablet Pose Event

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/mod.rs.html

Constructs a `Pose` object from raw frame data, handling potential NaN values by converting them to `NicheF32::NONE`. Emits a `ToolEvent::Pose` event. This is used when processing incoming tablet frame data.

```rust
let pose = Pose {
                    position,
                    // Try to make the Option into Niche'd option. If NaN, fail back to None.
                    distance: frame.distance.try_into().unwrap_or(NicheF32::NONE),
                    pressure: frame.pressure.try_into().unwrap_or(NicheF32::NONE),
                    roll: frame.roll.try_into().unwrap_or(NicheF32::NONE),
                    slider: frame.slider.try_into().unwrap_or(NicheF32::NONE),
                    tilt: frame.tilt.filter(|[x, y]| !x.is_nan() && !y.is_nan()),
                    wheel: frame.wheel.filter(|(delta, _)| !delta.is_nan()),
                    button_pressure: NicheF32::NONE,
                    contact_size: None,
                };

                self.events.push(raw_events::Event::Tool {
                    tool: tool.clone(),
                    event: raw_events::ToolEvent::Pose(pose),
                });
```

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

### Wayland Display Manager Build

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/builder.rs.html

Handles the construction of a Wayland display manager using raw display handles. This code is specific to Wayland environments.

```rust
raw_window_handle::RawDisplayHandle::Wayland(wlh) => {
                Ok(crate::platform::PlatformManager::Wayland(
                    // Safety: forwarded to this fn's contract.
                    unsafe {
                        crate::platform::wl::Manager::build_wayland_display(
                            self,
                            wlh.display.as_ptr().cast(),
                        )
                    },
                ))
            }
```

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

### by_ref

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AxisIter.html

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

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

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

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

### NicheF32 PartialEq<f32> Implementation

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/util.rs.html

Implements PartialEq between NicheF32 and f32, allowing direct comparison.

```rust
76impl PartialEq<f32> for NicheF32 {
77    fn eq(&self, other: &f32) -> bool {
78        if let Some(value) = self.get() {
79            value == *other
80        } else {
81            false
82        }
83    }
84}
```

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

### PartialOrd Implementation for ButtonID

Source: https://docs.rs/octotablet/0.1.0/octotablet/tool/struct.ButtonID.html

Provides partial ordering methods for ButtonID, including `partial_cmp`, `lt`, `le`, `gt`, and `ge`, for use in comparisons where a total order might not be guaranteed.

```rust
fn partial_cmp(&self, other: &ButtonID) -> Option<Ordering>
```

```rust
fn lt(&self, other: &Rhs) -> bool
```

```rust
fn le(&self, other: &Rhs) -> bool
```

```rust
fn gt(&self, other: &Rhs) -> bool
```

```rust
fn ge(&self, other: &Rhs) -> bool
```

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

### Create Child Objects for Tablet Pad

Source: https://docs.rs/octotablet/0.1.0/src/octotablet/platform/wl/pad_impl.rs.html

Defines how to create child objects for Wayland tablet pad groups, specifically for rings and strips. This macro handles the association of events with their respective child objects.

```rust
wayland_client::event_created_child!(
        TabletState,
        wl_tablet::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2,
        [
            wl_tablet::zwp_tablet_pad_group_v2::EVT_RING_OPCODE => (wl_tablet::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2, ()
            wl_tablet::zwp_tablet_pad_group_v2::EVT_STRIP_OPCODE => (wl_tablet::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2, ()
        ]
    );
```

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

### Builder::build_raw

Source: https://docs.rs/octotablet/0.1.0/octotablet/builder/struct.Builder.html

Builds a Manager instance from a display handle carrier with an unbound lifetime. The caller must ensure the display handle carrier remains valid for the lifetime of the Manager.

```APIDOC
## Builder::build_raw

### Description
Build from a display handle carrier, such as a reference to a `winit` window, with unbound lifetime.

### Safety
The given display handle carrier must be keep the window and display pointers valid as long as the returned `Manager` is alive.
_**`rwh`is dropped at the end of scope** - not kept alive within the `Manager` - thus cannot be used to ensure safety!_

### Method
```rust
pub unsafe fn build_raw( self, rwh: impl HasDisplayHandle + HasWindowHandle, ) -> Result<Manager, BuildError>
```

### Parameters
- **rwh** (`impl HasDisplayHandle + HasWindowHandle`) - A display handle carrier.

### Returns
A `Result` containing either a `Manager` instance on success or a `BuildError` on failure.
```

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

### partition

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.AxisIter.html

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

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

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

### Parameters
- **f** (FnMut(&Self::Item) -> bool) - The predicate to determine which collection an element belongs to.

### Type Parameters
- **B**: Must implement `Default` and `Extend<Self::Item>`.
```

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

### PartialOrd Implementation for HardwareID

Source: https://docs.rs/octotablet/0.1.0/octotablet/tool/struct.HardwareID.html

Provides partial ordering for HardwareID values, enabling comparisons like <, <=, >, >=.

```rust
fn partial_cmp(&self, other: &HardwareID) -> Option<Ordering>
```

```rust
fn lt(&self, other: &Rhs) -> bool
```

```rust
fn le(&self, other: &Rhs) -> bool
```

```rust
fn gt(&self, other: &Rhs) -> bool
```

```rust
fn ge(&self, other: &Rhs) -> bool
```

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

### Display Implementation for NicheF32Error

Source: https://docs.rs/octotablet/0.1.0/octotablet/util/enum.NicheF32Error.html

Provides a Display implementation for NicheF32Error, allowing it to be formatted for user-facing output.

```APIDOC
### impl Display for NicheF32Error

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

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

### Implement Any for T

Source: https://docs.rs/octotablet/0.1.0/octotablet/axis/struct.CircularInfo.html

Provides runtime type information for any type T that implements the 'static trait.

```rust
fn type_id(&self) -> TypeId
```
Tokens:
Raw