Struct ModeId 

pub struct ModeId { /* private fields */ }

Namespaced mode identifier with numeric discriminant.

Modes are identified by their owning module, a local name, and a numeric discriminant for O(1) identity comparison. The discriminant provides compile-time type safety when used with the Mode trait.

Identity

Two ModeIds are equal if and only if their module AND discriminant match. The name is for display purposes only and does not affect equality.

Example

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

let editor_module = ModuleId::new("editor");
let normal = ModeId::with_discriminant(editor_module.clone(), "NORMAL", 0);
let insert = ModeId::with_discriminant(editor_module, "INSERT", 1);

assert_eq!(normal.name(), "NORMAL");
assert_eq!(normal.discriminant(), 0);
assert_eq!(insert.discriminant(), 1);
assert_ne!(normal, insert);

Implementations

impl ModeId

pub const fn new(module: ModuleId, name: &'static str) -> Self

Create a new mode identifier with default discriminant (0).

This constructor is provided for backward compatibility. Prefer with_discriminant for new code.

pub const fn with_discriminant( module: ModuleId, name: &'static str, discriminant: u16, ) -> Self

Create a new mode identifier with explicit discriminant.

The discriminant should be unique within the module and stable across versions for serialization compatibility.

pub const fn module(&self) -> &ModuleId

Get the owning module.

pub const fn name(&self) -> &'static str

Get the display name.

pub const fn discriminant(&self) -> u16

Get the numeric discriminant.

Trait Implementations

impl Clone for ModeId

fn clone(&self) -> ModeId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModeId

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

Formats the value using the given formatter.

impl Display for ModeId

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

Formats the value using the given formatter.

impl<M: Mode> From<M> for ModeId

Blanket implementation: all Mode types convert to ModeId.

This allows ergonomic usage:

let stack = ModeStack::new(VimMode::Normal);  // No .into() needed
stack.push(VimMode::Insert);

fn from(mode: M) -> Self

Converts to this type from the input type.

impl Hash for ModeId

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 ModeId

fn eq(&self, other: &Self) -> 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 Eq for ModeId