Struct WindowBuffers 

pub struct WindowBuffers { /* private fields */ }

Implementations

impl WindowBuffers

pub fn new() -> Self

pub fn get(&self, id: &BufferId) -> Option<&EditorState>

pub fn get_mut(&mut self, id: &BufferId) -> Option<&mut EditorState>

pub fn insert( &mut self, id: BufferId, state: EditorState, ) -> Option<EditorState>

pub fn remove(&mut self, id: &BufferId) -> Option<EditorState>

pub fn contains_key(&self, id: &BufferId) -> bool

pub fn len(&self) -> usize

pub fn iter(&self) -> Iter<'_, BufferId, EditorState>

pub fn as_map(&self) -> &HashMap<BufferId, EditorState>

Read-only handle to the buffer state map, for rendering helpers that take &HashMap<BufferId, EditorState>. Mutation is not available through this path — go through one of the named methods.

pub fn as_map_mut(&mut self) -> &mut HashMap<BufferId, EditorState>

Mutable handle to the buffer state map, for the render path which needs to walk every buffer and mutate per-render scratch state. Doesn’t hand out the splits, so the “BufferId-in-splits-is-in-buffers” invariant is bounded by the size of insert/remove: render won’t add or remove buffers, it just mutates their contents. Prefer the with_* methods at any new call site.

pub fn ids(&self) -> Vec<BufferId>

Owned snapshot of every buffer id — for callers that need to mutate self while iterating.

pub fn find_id<F>(&self, predicate: F) -> Option<BufferId>

where F: FnMut(BufferId, &EditorState) -> bool,

pub fn count_where<F>(&self, predicate: F) -> usize

where F: FnMut(BufferId, &EditorState) -> bool,

pub fn paths(&self) -> Vec<PathBuf>

pub fn languages(&self) -> HashSet<String>

pub fn any_needs_semantic_redraw(&self) -> bool

pub fn splits(&self) -> Option<&(SplitManager, HashMap<LeafId, SplitViewState>)>

pub fn split_manager(&self) -> Option<&SplitManager>

pub fn split_view_states(&self) -> Option<&HashMap<LeafId, SplitViewState>>

pub fn has_splits(&self) -> bool

pub fn splits_mut( &mut self, ) -> Option<&mut (SplitManager, HashMap<LeafId, SplitViewState>)>

pub fn split_manager_mut(&mut self) -> Option<&mut SplitManager>

pub fn split_view_states_mut( &mut self, ) -> Option<&mut HashMap<LeafId, SplitViewState>>

pub fn set_splits( &mut self, splits: (SplitManager, HashMap<LeafId, SplitViewState>), )

pub fn clear_splits(&mut self)

pub fn with_buffer_and_split<F, R>( &mut self, buf: BufferId, split: LeafId, f: F, ) -> Option<R>

where F: FnOnce(&mut EditorState, &mut SplitViewState) -> R,

Run f with the buffer state and the named split’s view state. Returns None if either the buffer or the split is missing.

pub fn with_buffer_and_view_states<F, R>( &mut self, buf: BufferId, f: F, ) -> Option<R>

where F: FnOnce(&mut EditorState, &mut HashMap<LeafId, SplitViewState>) -> R,

Run f with the buffer state and the full per-leaf view-state map. Used by fold/cursor operations that touch every split hosting buf.

pub fn with_all_mut<F, R>(&mut self, f: F) -> Option<R>

where F: FnOnce(&mut HashMap<BufferId, EditorState>, &mut SplitManager, &mut HashMap<LeafId, SplitViewState>) -> R,

Run f with mutable refs to the buffer map, the split manager, and the per-leaf view state map. The render path and per-frame plugin-state snapshot need all three live at once — closure scope bounds the joint borrow.

Trait Implementations

impl Default for WindowBuffers

fn default() -> Self

Returns the “default value” for a type.

impl<'a> IntoIterator for &'a WindowBuffers

type Item = (&'a BufferId, &'a EditorState)

The type of the elements being iterated over.

type IntoIter = Iter<'a, BufferId, EditorState>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut WindowBuffers

type Item = (&'a BufferId, &'a mut EditorState)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, BufferId, EditorState>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.