Struct OperatorState 

pub struct OperatorState {
    pub operator: OperatorType,
    pub start_position: Option<Position>,
    pub operator_count: Option<usize>,
    pub motion_count: Option<usize>,
    pub register: Option<char>,
    pub pending_keys: KeySequence,
    pub initialized: bool,
}

State owned by an operator resolver.

Unlike VimSessionState.pending_operator, this state is owned by the resolver itself. This makes testing easier and eliminates runtime lookup of operator type.

State Lifecycle

When a mode is pushed (e.g., user presses ‘d’ in normal mode):

1. initialized is false
2. First resolve_with_session call reads pending_count/pending_register from VimSessionState
3. Sets initialized = true
4. Subsequent keys use the cached state
5. When mode is popped or cancelled, reset() clears the state

Fields

operator: OperatorType

The type of operator (delete, yank, change).

start_position: Option<Position>

Start position captured when entering operator mode.

operator_count: Option<usize>

Count applied before the operator (e.g., 2d in 2dw).

motion_count: Option<usize>

Count applied to the motion (e.g., 3 in d3w).

register: Option<char>

Target register for the operation.

pending_keys: KeySequence

Accumulated key sequence for multi-key motions.

initialized: bool

Whether the state has been initialized with context from normal mode.

On first key press in the mode, the resolver reads pending_count and pending_register from VimSessionState and sets this to true.

Implementations

impl OperatorState

pub fn new(operator: OperatorType) -> Self

Create a new operator state.

The state starts uninitialized. On first key press, the resolver will read pending_count and pending_register from VimSessionState.

pub fn with_context( operator: OperatorType, count: Option<usize>, register: Option<char>, ) -> Self

Create operator state with initial count and register.

Used in tests to pre-initialize state without going through VimSessionState.

pub fn set_start_position(&mut self, pos: Position)

Set the start position.

pub fn effective_count(&self) -> usize

Get the effective count (operator_count * motion_count, defaulting to 1).

pub fn explicit_count(&self) -> Option<usize>

Get count only if explicitly specified (not defaulted).

Returns None if no count was given, Some(n) if count was given. This preserves the distinction between “no count” and “count=1” for motions like G/gg where these have different semantics:

• G (no count) → last line
• 1G (count=1) → line 1

pub fn has_motion_count(&self) -> bool

Check if we have a motion count.

pub fn accumulate_motion_count(&mut self, key: &KeyEvent)

Accumulate a motion count digit.

pub fn take_motion_count(&mut self) -> Option<usize>

Take the motion count, clearing it.

pub fn push_key(&mut self, key: KeyEvent)

Add a key to pending sequence.

pub fn keys(&self) -> KeySequence

Get a clone of pending keys.

pub fn clear_keys(&mut self)

Clear pending keys.

pub fn reset(&mut self)

Reset all state for mode re-entry.

Called when the mode is exited (cancelled or completed). Clears all state including count and register so they can be re-read from VimSessionState on the next mode entry.

Trait Implementations

impl Clone for OperatorState

fn clone(&self) -> OperatorState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OperatorState

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

Formats the value using the given formatter.