Enum Register 

pub enum Register {
    Default,
    Slot(char),
    History(u8),
    System,
    Session(char),
    PeerHistory {
        client: usize,
        index: u8,
    },
}

Register addressing for the kernel register subsystem.

Represents storage locations using mechanism names (not editor-specific terminology). The kernel provides WHAT registers exist; modules decide HOW they map to user-facing keys.

Storage Routing

Different variants are stored in different subsystems:

Variant	Storage	Mutability
Default	Per-client RegisterBank	Read/Write
Slot(char)	Per-client RegisterBank	Read/Write
History(u8)	Per-client HistoryRing	Read-only
System	OS clipboard (driver)	Read/Write
Session(char)	Session-level shared storage	Read/Write
PeerHistory	Another client’s HistoryRing	Read-only

Example

use reovim_kernel::api::v1::Register;

let default = Register::Default;
assert!(default.is_bank_register());
assert!(!default.is_read_only());

let slot = Register::Slot('a');
assert!(slot.is_bank_register());

let history = Register::History(0);
assert!(history.is_read_only());

let session = Register::Session('A');
assert!(session.is_session_scoped());

Variants

Default

The default/fallback register.

Slot(char)

A keyed storage slot (a-z, 26 per-client slots).

History(u8)

Index into the per-client history ring (0-255).

System

System clipboard (OS-level).

Session(char)

Session-scoped shared register (A-Z, shared across all clients).

PeerHistory

Read another client’s history ring entry.

Fields

client: usize

Target client identifier.

index: u8

History ring index (0-255).

Implementations

impl Register

pub const fn is_bank_register(&self) -> bool

Whether this register is stored in per-client RegisterBank.

pub const fn is_read_only(&self) -> bool

Whether this register is read-only.

History and peer history registers cannot be written to directly. They are populated as side effects of other operations.

pub const fn is_session_scoped(&self) -> bool

Whether this register requires session-level access.

Session registers and peer history both need access to shared session state rather than per-client state.

Trait Implementations

impl Clone for Register

fn clone(&self) -> Register

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Register

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

Formats the value using the given formatter.

impl Hash for Register

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Register

fn eq(&self, other: &Register) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Register

impl Eq for Register

impl StructuralPartialEq for Register