Struct nvim_oxi::api::Buffer

pub struct Buffer(_);

A wrapper around a Neovim buffer handle.

Implementations

impl Buffer

pub fn current() -> Buffer

Shorthand for get_current_buf.

pub fn attach(&self, send_buffer: bool, opts: &BufAttachOpts) -> Result<(), Error>

Binding to nvim_buf_attach.

Used to register a set of callbacks on specific buffer events.

pub fn call<F, R>(&self, fun: F) -> Result<R, Error>where
    F: 'static + FnOnce(()) -> Result<R, Error>,
    R: Pushable + FromObject,

Binding to nvim_buf_call.

Calls a function with this buffer as the temporary current buffer.

pub fn create_user_command<Cmd>(
    &mut self,
    name: &str,
    command: Cmd,
    opts: &CreateCommandOpts
) -> Result<(), Error>where
    Cmd: StringOrFunction<CommandArgs, ()>,

Binding to nvim_buf_create_user_command.

Creates a new buffer-local user command.

pub fn del_keymap(&mut self, mode: Mode, lhs: &str) -> Result<(), Error>

Binding to nvim_buf_del_keymap.

Unmaps a buffer-local mapping for the given mode.

pub fn del_mark(&mut self, name: char) -> Result<(), Error>

Binding to nvim_buf_del_mark.

Deletes a named mark in the buffer.

pub fn del_user_command(&mut self, name: &str) -> Result<(), Error>

Binding to nvim_buf_del_user_command.

Deletes a buffer-local user-command. Use del_user_command to delete a global command.

pub fn del_var(&mut self, name: &str) -> Result<(), Error>

Binding to nvim_buf_del_var.

Removes a buffer-scoped (b:) variable.

pub fn delete(self, opts: &BufDeleteOpts) -> Result<(), Error>

Binding to nvim_buf_delete.

Deletes the buffer (not allowed while textlock is active).

pub fn get_changedtick(&self) -> Result<u32, Error>

Binding to nvim_buf_get_changedtick.

pub fn get_commands(
    &self,
    opts: &GetCommandsOpts
) -> Result<impl SuperIterator<CommandInfos>, Error>

Binding to nvim_buf_get_commands.

pub fn get_keymap(
    &self,
    mode: Mode
) -> Result<impl SuperIterator<KeymapInfos>, Error>

Binding to nvim_buf_get_keymap.

pub fn get_lines<R>(
    &self,
    line_range: R,
    strict_indexing: bool
) -> Result<impl SuperIterator<String>, Error>where
    R: RangeBounds<usize>,

Binding to nvim_buf_get_lines.

Gets a line range from the buffer. Indexing is zero-based, end-exclusive.

pub fn get_mark(&self, name: char) -> Result<(usize, usize), Error>

Binding to nvim_buf_get_mark.

Returns a (1-0) indexed (row, col) tuple representing the position of the named mark.

pub fn get_name(&self) -> Result<PathBuf, Error>

Binding to nvim_buf_get_name.

Returns the full filepath of the buffer.

pub fn get_offset(&self, index: usize) -> Result<usize, Error>

Binding to nvim_buf_get_offset.

Returns the 0-indexed byte offset of a line.

pub fn get_option<Opt>(&self, name: &str) -> Result<Opt, Error>where
    Opt: FromObject,

Binding to nvim_buf_get_option.

Gets a buffer option value.

pub fn get_text<R>(
    &self,
    line_range: R,
    start_col: usize,
    end_col: usize,
    opts: &GetTextOpts
) -> Result<impl SuperIterator<String>, Error>where
    R: RangeBounds<usize>,

Binding to nvim_buf_get_text.

Gets a range from the buffer. This differs from Buffer::get_lines in that it allows retrieving only portions of a line.

Indexing is zero-based, with both row and column indices being end-exclusive.

pub fn get_var<Var>(&self, name: &str) -> Result<Var, Error>where
    Var: FromObject,

Binding to nvim_buf_get_var.

Gets a buffer-scoped (b:) variable.

pub fn is_loaded(&self) -> bool

Binding to nvim_buf_is_loaded.

Checks if a buffer is valid and loaded.

pub fn is_valid(&self) -> bool

Binding to nvim_buf_is_valid.

Checks if a buffer is valid.

pub fn line_count(&self) -> Result<usize, Error>

Binding to nvim_buf_line_count.

Returns the number of lines in the given buffer.

pub fn set_keymap(
    &mut self,
    mode: Mode,
    lhs: &str,
    rhs: &str,
    opts: &SetKeymapOpts
) -> Result<(), Error>

Binding to nvim_buf_set_keymap.

Sets a buffer-local mapping for the given mode. To set a global mapping use set_keymap instead.

pub fn set_lines<Line, Lines, R>(
    &mut self,
    line_range: R,
    strict_indexing: bool,
    replacement: Lines
) -> Result<(), Error>where
    R: RangeBounds<usize>,
    Lines: IntoIterator<Item = Line>,
    Line: Into<String>,

Binding to nvim_buf_set_lines.

Sets (replaces) a line-range in the buffer. Indexing is zero-based, end-exclusive.

pub fn set_mark(
    &mut self,
    name: char,
    line: usize,
    col: usize
) -> Result<(), Error>

Binding to nvim_buf_set_mark.

Sets a named mark in the buffer. Marks are (1,0)-indexed, and passing 0 as line deletes the mark.

pub fn set_name<Name>(&mut self, name: Name) -> Result<(), Error>where
    Name: AsRef<Path>,

Binding to nvim_buf_set_name.

Sets the full file name for a buffer.

pub fn set_option<V>(&mut self, name: &str, value: V) -> Result<(), Error>where
    V: ToObject,

Binding to nvim_buf_set_option.

Sets a buffer option value. Passing None as value deletes the option (only works if there’s a global fallback).

pub fn set_text<Line, Lines, R>(
    &mut self,
    line_range: R,
    start_col: usize,
    end_col: usize,
    replacement: Lines
) -> Result<(), Error>where
    R: RangeBounds<usize>,
    Lines: IntoIterator<Item = Line>,
    Line: Into<String>,

Binding to nvim_buf_set_text.

Sets (replaces) a range in the buffer. Indexing is zero-based, with both row and column indices being end-exclusive.

pub fn set_var<V>(&mut self, name: &str, value: V) -> Result<(), Error>where
    V: ToObject,

Binding to nvim_buf_set_var.

Sets a buffer-scoped (b:) variable.

impl Buffer

pub fn add_highlight<R>(
    &mut self,
    ns_id: u32,
    hl_group: &str,
    line: usize,
    byte_range: R
) -> Result<i64, Error>where
    R: RangeBounds<usize>,

Binding to nvim_buf_add_highlight.

Adds a highlight to the buffer. Both line and byte_range are 0-indexed.

pub fn clear_namespace<R>(
    &mut self,
    ns_id: u32,
    line_range: R
) -> Result<(), Error>where
    R: RangeBounds<usize>,

Binding to nvim_buf_clear_namespace.

Clears namespaced objects like highlights, extmarks, or virtual text from a region.

The line range is 0-indexed.

pub fn del_extmark(&mut self, ns_id: u32, extmark_id: u32) -> Result<(), Error>

Binding to nvim_buf_del_extmark.

Removes an extmark from the buffer.

pub fn get_extmark_by_id(
    &self,
    ns_id: u32,
    extmark_id: u32,
    opts: &GetExtmarkByIdOpts
) -> Result<(usize, usize, Option<ExtmarkInfos>), Error>

Binding to nvim_buf_get_extmark_by_id.

The first two elements of the returned tuple represent the 0-indexed row, col position of the extmark. The last element is only present if the details option field was set to true.

pub fn get_extmarks(
    &self,
    ns_id: u32,
    start: ExtmarkPosition,
    end: ExtmarkPosition,
    opts: &GetExtmarksOpts
) -> Result<impl SuperIterator<(u32, usize, usize, Option<ExtmarkInfos>)>, Error>

Bindings to nvim_buf_get_extmarks.

Gets all the extmarks in a buffer region specified by start and end positions. Returns an iterator over (extmark_id, row, col, infos) tuples in “traversal order”. Like for Buffer::get_extmark_by_id, the infos are present only if the details option field was set to true.

pub fn set_extmark(
    &mut self,
    ns_id: u32,
    line: usize,
    col: usize,
    opts: &SetExtmarkOpts
) -> Result<u32, Error>

Binding to nvim_buf_set_extmark.

Creates or updates an extmark. Both line and col are 0-indexed. Returns the id of the created/updated extmark.

Trait Implementations

impl Clone for Buffer

fn clone(&self) -> Buffer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Buffer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Buffer

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Buffer, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Buffer

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

Formats the value using the given formatter.

impl From<&Buffer> for Object

fn from(buf: &Buffer) -> Object

Converts to this type from the input type.

impl From<Buffer> for Object

fn from(buf: Buffer) -> Object

Converts to this type from the input type.

impl<H> From<H> for Bufferwhere
    H: Into<i32>,

fn from(handle: H) -> Buffer

Converts to this type from the input type.

impl FromObject for Buffer

fn from_object(obj: Object) -> Result<Buffer, Error>

impl Hash for Buffer

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Buffer> for Buffer

fn eq(&self, other: &Buffer) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Poppable for Buffer

unsafe fn pop(lstate: *mut lua_State) -> Result<Buffer, Error>

Pops the value at the top of the stack.

impl Pushable for Buffer

unsafe fn push(self, lstate: *mut lua_State) -> Result<i32, Error>

Pushes all its values on the Lua stack, returning the number of values that it pushed.

impl Serialize for Buffer

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Buffer

impl StructuralEq for Buffer

impl StructuralPartialEq for Buffer