Struct ModeStack 

pub struct ModeStack { /* private fields */ }

Mode stack for push/pop mode switching.

Supports vim-style mode stacking where modes can be pushed and popped. For example, entering operator-pending mode pushes onto the stack, and completing/canceling the operation pops back.

Generic Mode Support

All methods accept impl Into<ModeId>, allowing both ModeId and any type implementing Mode to be used directly:

let mut stack = ModeStack::new(VimMode::Normal);  // VimMode implements Mode
stack.push(VimMode::OperatorPending);

Example

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

let module = ModuleId::new("editor");
let normal = ModeId::with_discriminant(module.clone(), "NORMAL", 0);
let insert = ModeId::with_discriminant(module.clone(), "INSERT", 1);
let op_pending = ModeId::with_discriminant(module, "OP-PEND", 5);

let mut stack = ModeStack::new(normal.clone());
assert_eq!(stack.current(), &normal);

// Push operator-pending mode
stack.push(op_pending.clone());
assert_eq!(stack.current(), &op_pending);

// Pop back to normal
assert_eq!(stack.pop(), Some(op_pending));
assert_eq!(stack.current(), &normal);

// Set directly to insert (replaces current)
stack.set(insert.clone());
assert_eq!(stack.current(), &insert);

Implementations

impl ModeStack

pub fn new<M: Into<ModeId>>(initial: M) -> Self

Create a new mode stack with an initial mode.

Accepts any type that implements Into<ModeId>, including ModeId itself and any type implementing Mode.

pub fn current(&self) -> &ModeId

Get the current (top) mode.

Panics

This function will never panic in normal use. It only panics if the internal invariant (stack has at least one element) is violated, which indicates a bug.

pub fn push<M: Into<ModeId>>(&mut self, mode: M)

Push a new mode onto the stack.

Accepts any type that implements Into<ModeId>.

pub fn pop(&mut self) -> Option<ModeId>

Pop the top mode from the stack.

Returns None if only one mode remains (cannot pop the base mode).

pub fn set<M: Into<ModeId>>(&mut self, mode: M)

Set the current mode, replacing the top of the stack.

This is equivalent to pop + push, but works even when only one mode exists. Accepts any type that implements Into<ModeId>.

pub const fn depth(&self) -> usize

Get the stack depth.

pub const fn is_base(&self) -> bool

Check if we’re in the base mode (stack depth is 1).

pub fn as_slice(&self) -> &[ModeId]

Get all modes in the stack (bottom to top).

pub fn home(&self) -> &ModeId

Get the home (base) mode.

The home mode is the first mode pushed onto the stack and cannot be popped.

Panics

This function will never panic in normal use. It only panics if the internal invariant (stack has at least one element) is violated, which indicates a bug.

pub fn contains(&self, mode_id: &ModeId) -> bool

Check if a mode is anywhere in the stack.

Trait Implementations

impl Clone for ModeStack

fn clone(&self) -> ModeStack

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModeStack

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

Formats the value using the given formatter.