Struct zed2::languages::Buffer

pub struct Buffer { /* private fields */ }

Implementations

impl Buffer

pub fn new<T>(replica_id: u16, id: u64, base_text: T) -> Bufferwhere T: Into<String>,

pub fn remote(remote_id: u64, replica_id: u16, base_text: String) -> Buffer

pub fn from_proto( replica_id: u16, message: BufferState, file: Option<Arc<dyn File, Global>> ) -> Result<Buffer, Error>

pub fn to_proto(&self) -> BufferState

pub fn serialize_ops( &self, since: Option<Global>, cx: &AppContext ) -> Task<Vec<Operation, Global>>

pub fn with_language( self, language: Arc<Language, Global>, cx: &mut ModelContext<'_, Buffer> ) -> Buffer

pub fn build( buffer: Buffer, diff_base: Option<String>, file: Option<Arc<dyn File, Global>> ) -> Buffer

pub fn snapshot(&self) -> BufferSnapshot

pub fn as_text_snapshot(&self) -> &BufferSnapshot

pub fn text_snapshot(&self) -> BufferSnapshot

pub fn file(&self) -> Option<&Arc<dyn File, Global>>

pub fn saved_version(&self) -> &Global

pub fn saved_version_fingerprint(&self) -> HashMatrix

pub fn saved_mtime(&self) -> SystemTime

pub fn set_language( &mut self, language: Option<Arc<Language, Global>>, cx: &mut ModelContext<'_, Buffer> )

pub fn set_language_registry( &mut self, language_registry: Arc<LanguageRegistry, Global> )

pub fn did_save( &mut self, version: Global, fingerprint: HashMatrix, mtime: SystemTime, cx: &mut ModelContext<'_, Buffer> )

pub fn reload( &mut self, cx: &mut ModelContext<'_, Buffer> ) -> Receiver<Option<Transaction>>

pub fn did_reload( &mut self, version: Global, fingerprint: HashMatrix, line_ending: LineEnding, mtime: SystemTime, cx: &mut ModelContext<'_, Buffer> )

pub fn file_updated( &mut self, new_file: Arc<dyn File, Global>, cx: &mut ModelContext<'_, Buffer> )

pub fn diff_base(&self) -> Option<&str>

pub fn set_diff_base( &mut self, diff_base: Option<String>, cx: &mut ModelContext<'_, Buffer> )

pub fn git_diff_recalc( &mut self, cx: &mut ModelContext<'_, Buffer> ) -> Option<Task<()>>

pub fn close(&mut self, cx: &mut ModelContext<'_, Buffer>)

pub fn language(&self) -> Option<&Arc<Language, Global>>

pub fn language_at<D>(&self, position: D) -> Option<Arc<Language, Global>>where D: ToOffset,

pub fn parse_count(&self) -> usize

pub fn selections_update_count(&self) -> usize

pub fn diagnostics_update_count(&self) -> usize

pub fn file_update_count(&self) -> usize

pub fn git_diff_update_count(&self) -> usize

pub fn contains_unknown_injections(&self) -> bool

pub fn reparse(&mut self, cx: &mut ModelContext<'_, Buffer>)

Called after an edit to synchronize the buffer’s main parse tree with the buffer’s new underlying state.

Locks the syntax map and interpolates the edits since the last reparse into the foreground syntax tree.

Then takes a stable snapshot of the syntax map before unlocking it. The snapshot with the interpolated edits is sent to a background thread, where we ask Tree-sitter to perform an incremental parse.

Meanwhile, in the foreground, we block the main thread for up to 1ms waiting on the parse to complete. As soon as it completes, we proceed synchronously, unless a 1ms timeout elapses.

If we time out waiting on the parse, we spawn a second task waiting until the parse does complete and return with the interpolated tree still in the foreground. When the background parse completes, call back into the main thread and assign the foreground parse state.

If the buffer or grammar changed since the start of the background parse, initiate an additional reparse recursively. To avoid concurrent parses for the same buffer, we only initiate a new parse if we are not already parsing in the background.

pub fn update_diagnostics( &mut self, server_id: LanguageServerId, diagnostics: DiagnosticSet, cx: &mut ModelContext<'_, Buffer> )

pub fn edit_for_indent_size_adjustment( row: u32, current_size: IndentSize, new_size: IndentSize ) -> Option<(Range<Point>, String)>

pub fn diff(&self, new_text: String, cx: &AppContext) -> Task<Diff>

pub fn remove_trailing_whitespace(&self, cx: &AppContext) -> Task<Diff>

Spawn a background task that searches the buffer for any whitespace at the ends of a lines, and returns a Diff that removes that whitespace.

pub fn ensure_final_newline(&mut self, cx: &mut ModelContext<'_, Buffer>)

Ensure that the buffer ends with a single newline character, and no other whitespace.

pub fn apply_diff( &mut self, diff: Diff, cx: &mut ModelContext<'_, Buffer> ) -> Option<Lamport>

Apply a diff to the buffer. If the buffer has changed since the given diff was calculated, then adjust the diff to account for those changes, and discard any parts of the diff that conflict with those changes.

pub fn is_dirty(&self) -> bool

pub fn has_conflict(&self) -> bool

pub fn subscribe(&mut self) -> Subscription

pub fn start_transaction(&mut self) -> Option<Lamport>

pub fn start_transaction_at(&mut self, now: Instant) -> Option<Lamport>

pub fn end_transaction( &mut self, cx: &mut ModelContext<'_, Buffer> ) -> Option<Lamport>

pub fn end_transaction_at( &mut self, now: Instant, cx: &mut ModelContext<'_, Buffer> ) -> Option<Lamport>

pub fn push_transaction(&mut self, transaction: Transaction, now: Instant)

pub fn finalize_last_transaction(&mut self) -> Option<&Transaction>

pub fn group_until_transaction(&mut self, transaction_id: Lamport)

pub fn forget_transaction(&mut self, transaction_id: Lamport)

pub fn merge_transactions(&mut self, transaction: Lamport, destination: Lamport)

pub fn wait_for_edits( &mut self, edit_ids: impl IntoIterator<Item = Lamport> ) -> impl Future<Output = Result<(), Error>>

pub fn wait_for_anchors( &mut self, anchors: impl IntoIterator<Item = Anchor> ) -> impl Future<Output = Result<(), Error>> + 'static

pub fn wait_for_version( &mut self, version: Global ) -> impl Future<Output = Result<(), Error>>

pub fn give_up_waiting(&mut self)

pub fn set_active_selections( &mut self, selections: Arc<[Selection<Anchor>], Global>, line_mode: bool, cursor_shape: CursorShape, cx: &mut ModelContext<'_, Buffer> )

pub fn remove_active_selections(&mut self, cx: &mut ModelContext<'_, Buffer>)

pub fn set_text<T>( &mut self, text: T, cx: &mut ModelContext<'_, Buffer> ) -> Option<Lamport>where T: Into<Arc<str, Global>>,

pub fn edit<I, S, T>( &mut self, edits_iter: I, autoindent_mode: Option<AutoindentMode>, cx: &mut ModelContext<'_, Buffer> ) -> Option<Lamport>where I: IntoIterator<Item = (Range<S>, T)>, S: ToOffset, T: Into<Arc<str, Global>>,

pub fn apply_ops<I>( &mut self, ops: I, cx: &mut ModelContext<'_, Buffer> ) -> Result<(), Error>where I: IntoIterator<Item = Operation>,

pub fn remove_peer( &mut self, replica_id: u16, cx: &mut ModelContext<'_, Buffer> )

pub fn undo(&mut self, cx: &mut ModelContext<'_, Buffer>) -> Option<Lamport>

pub fn undo_transaction( &mut self, transaction_id: Lamport, cx: &mut ModelContext<'_, Buffer> ) -> bool

pub fn undo_to_transaction( &mut self, transaction_id: Lamport, cx: &mut ModelContext<'_, Buffer> ) -> bool

pub fn redo(&mut self, cx: &mut ModelContext<'_, Buffer>) -> Option<Lamport>

pub fn redo_to_transaction( &mut self, transaction_id: Lamport, cx: &mut ModelContext<'_, Buffer> ) -> bool

pub fn set_completion_triggers( &mut self, triggers: Vec<String, Global>, cx: &mut ModelContext<'_, Buffer> )

pub fn completion_triggers(&self) -> &[String]

Methods from Deref<Target = Buffer>

pub fn version(&self) -> Global

pub fn snapshot(&self) -> BufferSnapshot

pub fn replica_id(&self) -> u16

pub fn remote_id(&self) -> u64

pub fn deferred_ops_len(&self) -> usize

pub fn transaction_group_interval(&self) -> Duration

pub fn peek_undo_stack(&self) -> Option<&HistoryEntry>

pub fn peek_redo_stack(&self) -> Option<&HistoryEntry>

pub fn base_text(&self) -> &Rope

pub fn operations(&self) -> &TreeMap<Lamport, Operation>

pub fn edited_ranges_for_transaction<D, 'a>( &'a self, transaction: &'a Transaction ) -> impl Iterator<Item = Range<D>> + 'awhere D: TextDimension,

Methods from Deref<Target = BufferSnapshot>

pub fn as_rope(&self) -> &Rope

pub fn remote_id(&self) -> u64

pub fn replica_id(&self) -> u16

pub fn row_count(&self) -> u32

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn chars(&self) -> impl Iterator<Item = char>

pub fn chars_for_range<T>(&self, range: Range<T>) -> impl Iterator<Item = char>where T: ToOffset,

pub fn reversed_chars_for_range<T>( &self, range: Range<T> ) -> impl Iterator<Item = char>where T: ToOffset,

pub fn contains_str_at<T>(&self, position: T, needle: &str) -> boolwhere T: ToOffset,

pub fn common_prefix_at<T>(&self, position: T, needle: &str) -> Range<T>where T: ToOffset + TextDimension,

pub fn text(&self) -> String

pub fn line_ending(&self) -> LineEnding

pub fn deleted_text(&self) -> String

pub fn fragments(&self) -> impl Iterator<Item = &Fragment>

pub fn text_summary(&self) -> TextSummary

pub fn max_point(&self) -> Point

pub fn max_point_utf16(&self) -> PointUtf16

pub fn point_to_offset(&self, point: Point) -> usize

pub fn point_utf16_to_offset(&self, point: PointUtf16) -> usize

pub fn unclipped_point_utf16_to_offset( &self, point: Unclipped<PointUtf16> ) -> usize

pub fn unclipped_point_utf16_to_point( &self, point: Unclipped<PointUtf16> ) -> Point

pub fn offset_utf16_to_offset(&self, offset: OffsetUtf16) -> usize

pub fn offset_to_offset_utf16(&self, offset: usize) -> OffsetUtf16

pub fn offset_to_point(&self, offset: usize) -> Point

pub fn offset_to_point_utf16(&self, offset: usize) -> PointUtf16

pub fn point_to_point_utf16(&self, point: Point) -> PointUtf16

pub fn version(&self) -> &Global

pub fn chars_at<T>(&self, position: T) -> impl Iterator<Item = char>where T: ToOffset,

pub fn reversed_chars_at<T>(&self, position: T) -> impl Iterator<Item = char>where T: ToOffset,

pub fn reversed_chunks_in_range<T>(&self, range: Range<T>) -> Chunks<'_> where T: ToOffset,

pub fn bytes_in_range<T>(&self, range: Range<T>) -> Bytes<'_> where T: ToOffset,

pub fn reversed_bytes_in_range<T>(&self, range: Range<T>) -> Bytes<'_> where T: ToOffset,

pub fn text_for_range<T>(&self, range: Range<T>) -> Chunks<'_> where T: ToOffset,

pub fn line_len(&self, row: u32) -> u32

pub fn is_line_blank(&self, row: u32) -> bool

pub fn text_summary_for_range<D, O>(&self, range: Range<O>) -> Dwhere O: ToOffset, D: TextDimension,

pub fn summaries_for_anchors<'a, D, A>( &'a self, anchors: A ) -> impl Iterator<Item = D> + 'awhere D: 'a + TextDimension, A: 'a + IntoIterator<Item = &'a Anchor>,

pub fn summaries_for_anchors_with_payload<'a, D, A, T>( &'a self, anchors: A ) -> impl Iterator<Item = (D, T)> + 'awhere D: 'a + TextDimension, A: 'a + IntoIterator<Item = (&'a Anchor, T)>,

pub fn anchor_before<T>(&self, position: T) -> Anchorwhere T: ToOffset,

pub fn anchor_after<T>(&self, position: T) -> Anchorwhere T: ToOffset,

pub fn anchor_at<T>(&self, position: T, bias: Bias) -> Anchorwhere T: ToOffset,

pub fn can_resolve(&self, anchor: &Anchor) -> bool

pub fn clip_offset(&self, offset: usize, bias: Bias) -> usize

pub fn clip_point(&self, point: Point, bias: Bias) -> Point

pub fn clip_offset_utf16(&self, offset: OffsetUtf16, bias: Bias) -> OffsetUtf16

pub fn clip_point_utf16( &self, point: Unclipped<PointUtf16>, bias: Bias ) -> PointUtf16

pub fn edits_since<D, 'a>( &'a self, since: &'a Global ) -> impl Iterator<Item = Edit<D>> + 'awhere D: TextDimension + Ord,

pub fn anchored_edits_since<D, 'a>( &'a self, since: &'a Global ) -> impl Iterator<Item = (Edit<D>, Range<Anchor>)> + 'awhere D: TextDimension + Ord,

pub fn edits_since_in_range<D, 'a>( &'a self, since: &'a Global, range: Range<Anchor> ) -> impl Iterator<Item = Edit<D>> + 'awhere D: TextDimension + Ord,

pub fn anchored_edits_since_in_range<D, 'a>( &'a self, since: &'a Global, range: Range<Anchor> ) -> impl Iterator<Item = (Edit<D>, Range<Anchor>)> + 'awhere D: TextDimension + Ord,

Trait Implementations

impl Deref for Buffer

type Target = Buffer

The resulting type after dereferencing.

fn deref(&self) -> &<Buffer as Deref>::Target

Dereferences the value.

impl Item for Buffer

fn entry_id(&self, cx: &AppContext) -> Option<ProjectEntryId>

fn project_path(&self, cx: &AppContext) -> Option<ProjectPath>

impl EventEmitter<Event> for Buffer