Trait Mode

Source

pub trait Mode:
    Copy
    + Clone
    + PartialEq
    + Eq
    + Hash
    + Send
    + Sync
    + 'static {
    // Required methods
    fn module() -> ModuleId
       where Self: Sized;
    fn discriminant(&self) -> u16;
    fn display_name(&self) -> &'static str;
    fn cursor_style(&self) -> CursorStyle;
    fn accepts_char_input(&self) -> bool;

    // Provided methods
    fn id(&self) -> ModeId
       where Self: Sized { ... }
    fn has_selection(&self) -> bool { ... }
    fn inherits_from(&self) -> Option<Self>
       where Self: Sized { ... }
    fn is_entry(&self) -> bool { ... }
}

Expand description

Mode trait for type-safe, compile-time enforced mode ownership.

Policy modules (e.g., vim, emacs) define their own Mode enums and implement this trait. The trait provides both identity and behavior information, allowing the kernel and drivers to query mode properties without knowing the concrete type.

§Type Safety

The trait requires Copy + Clone + PartialEq + Eq + Hash to ensure modes are lightweight value types that can be efficiently compared and stored. This also makes the trait not object-safe, which is intentional: runtime storage uses ModeId, not dyn Mode.

§Blanket Implementation

All Mode types automatically implement From<M> for ModeId, allowing ergonomic conversion when storing modes in ModeStack or ModeRegistry.

§Example

use reovim_kernel::api::v1::{Mode, ModeId, ModuleId, CursorStyle};

const VIM_MODULE: ModuleId = ModuleId::new("vim");

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u16)]
enum VimMode {
    Normal = 0,
    Insert = 1,
    Visual = 2,
}

impl Mode for VimMode {
    fn module() -> ModuleId { VIM_MODULE }

    fn discriminant(&self) -> u16 { *self as u16 }

    fn display_name(&self) -> &'static str {
        match self {
            Self::Normal => "NORMAL",
            Self::Insert => "INSERT",
            Self::Visual => "VISUAL",
        }
    }

    fn cursor_style(&self) -> CursorStyle {
        match self {
            Self::Insert => CursorStyle::Bar,
            _ => CursorStyle::Block,
        }
    }

    fn accepts_char_input(&self) -> bool {
        matches!(self, Self::Insert)
    }
}