swaitsandClaude Opus 4.6
3102fc747a
Implement full SSD1306 OLED display support: - Splash screen on boot (1.5s) with project name, version, board - Dashboard showing radio state, config, counters, RSSI/SNR - RSSI history sparkline (64-sample ring buffer, 2px-wide bars) - DisplayOn/DisplayOff host commands routed via dedicated channel - Pure render functions against generic DrawTarget (no hardware coupling) - Display on/off control bypasses radio task entirely Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
122 lines
2.8 KiB
Rust
122 lines
2.8 KiB
Rust
#![cfg_attr(test, deny(warnings))]
|
|
#![deny(missing_docs)]
|
|
#![cfg_attr(not(feature = "std"), no_std)]
|
|
|
|
//! # Void
|
|
//!
|
|
//! The uninhabited void type for use in statically impossible cases.
|
|
//!
|
|
//! In its own crate so all the users in the ecosystem can share the same type.
|
|
//! This crate also comes ready with several extension traits for Result that add
|
|
//! extra functionality to `Result<T, Void>` and `Result<Void, E>`.
|
|
//!
|
|
|
|
#[cfg(not(feature = "std"))]
|
|
mod coreprovider {
|
|
extern crate core;
|
|
pub use core::{fmt, cmp};
|
|
}
|
|
|
|
#[cfg(feature = "std")]
|
|
mod coreprovider {
|
|
pub use std::{fmt, cmp, error};
|
|
}
|
|
|
|
use coreprovider::*;
|
|
|
|
/// The empty type for cases which can't occur.
|
|
#[derive(Copy)]
|
|
pub enum Void { }
|
|
|
|
impl Clone for Void {
|
|
fn clone(&self) -> Void {
|
|
unreachable(*self)
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for Void {
|
|
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
|
|
unreachable(*self)
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Void {
|
|
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
|
|
unreachable(*self)
|
|
}
|
|
}
|
|
|
|
impl<T> cmp::PartialEq<T> for Void {
|
|
fn eq(&self, _: &T) -> bool {
|
|
unreachable(*self)
|
|
}
|
|
}
|
|
|
|
impl<T> cmp::PartialOrd<T> for Void {
|
|
fn partial_cmp(&self, _: &T) -> Option<cmp::Ordering> {
|
|
unreachable(*self)
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "std")]
|
|
impl error::Error for Void {
|
|
fn description(&self) -> &str {
|
|
unreachable(*self)
|
|
}
|
|
|
|
fn cause(&self) -> Option<&error::Error> {
|
|
unreachable(*self)
|
|
}
|
|
}
|
|
|
|
/// A safe version of `intrinsincs::unreachable`.
|
|
///
|
|
/// If this typechecks, anything that causes this to run is unreachable code.
|
|
///
|
|
/// Calling this function in reachable code invokes undefined behavior, but
|
|
/// should not be possible unless `unsafe` was used elsewhere to construct
|
|
/// an instance of `Void` (which is already undefined behavior).
|
|
#[inline(always)]
|
|
pub fn unreachable(x: Void) -> ! {
|
|
match x {}
|
|
}
|
|
|
|
/// Extensions to `Result<T, Void>`
|
|
pub trait ResultVoidExt<T>: Sized {
|
|
/// Get the value out of a wrapper.
|
|
fn void_unwrap(self) -> T;
|
|
}
|
|
|
|
impl<T> ResultVoidExt<T> for Result<T, Void> {
|
|
/// Get the value out of an always-ok Result.
|
|
///
|
|
/// Never panics, since it is statically known to be Ok.
|
|
#[inline]
|
|
fn void_unwrap(self) -> T {
|
|
match self {
|
|
Ok(val) => val,
|
|
Err(e) => unreachable(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Extensions to `Result<Void, E>`
|
|
pub trait ResultVoidErrExt<E>: Sized {
|
|
/// Get the error out of a wrapper.
|
|
fn void_unwrap_err(self) -> E;
|
|
}
|
|
|
|
impl<E> ResultVoidErrExt<E> for Result<Void, E> {
|
|
/// Get the error out of an always-err Result.
|
|
///
|
|
/// Never panics, since it is statically known to be Err.
|
|
#[inline]
|
|
fn void_unwrap_err(self) -> E {
|
|
match self {
|
|
Ok(v) => unreachable(v),
|
|
Err(e) => e
|
|
}
|
|
}
|
|
}
|
|
|