160 lines
4.0 KiB
Rust
160 lines
4.0 KiB
Rust
use std::ops::{Deref, DerefMut};
|
|
use std::cell::{Cell, RefCell, RefMut};
|
|
use std::sync::{Arc, Mutex, MutexGuard};
|
|
|
|
use super::ErrorReport;
|
|
use neovim_lib::{Neovim, NeovimApi};
|
|
|
|
#[derive(Clone, Copy, PartialEq)]
|
|
enum NeovimClientState {
|
|
Uninitialized,
|
|
InitInProgress,
|
|
Initialized,
|
|
Error,
|
|
}
|
|
|
|
pub enum NeovimRef<'a> {
|
|
SingleThreaded(RefMut<'a, Neovim>),
|
|
MultiThreaded(MutexGuard<'a, Option<Neovim>>),
|
|
}
|
|
|
|
impl<'a> NeovimRef<'a> {
|
|
fn from_nvim(nvim: RefMut<'a, Neovim>) -> Self {
|
|
NeovimRef::SingleThreaded(nvim)
|
|
}
|
|
|
|
fn from_nvim_async(nvim_async: &'a NeovimClientAsync) -> Option<NeovimRef<'a>> {
|
|
let guard = nvim_async.nvim.lock().unwrap();
|
|
|
|
if guard.is_some() {
|
|
Some(NeovimRef::MultiThreaded(guard))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
pub fn non_blocked(mut self) -> Option<Self> {
|
|
self.get_mode().ok_and_report().and_then(|mode| {
|
|
mode.iter()
|
|
.find(|kv| kv.0.as_str().map(|key| key == "blocking").unwrap_or(false))
|
|
.map(|kv| kv.1.as_bool().unwrap_or(false))
|
|
.and_then(|block| if block { None } else { Some(self) })
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<'a> Deref for NeovimRef<'a> {
|
|
type Target = Neovim;
|
|
|
|
fn deref(&self) -> &Neovim {
|
|
match *self {
|
|
NeovimRef::SingleThreaded(ref nvim) => &*nvim,
|
|
NeovimRef::MultiThreaded(ref nvim) => (&*nvim).as_ref().unwrap(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> DerefMut for NeovimRef<'a> {
|
|
fn deref_mut(&mut self) -> &mut Neovim {
|
|
match *self {
|
|
NeovimRef::SingleThreaded(ref mut nvim) => &mut *nvim,
|
|
NeovimRef::MultiThreaded(ref mut nvim) => (&mut *nvim).as_mut().unwrap(),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct NeovimClientAsync {
|
|
nvim: Arc<Mutex<Option<Neovim>>>,
|
|
}
|
|
|
|
impl NeovimClientAsync {
|
|
fn new() -> Self {
|
|
NeovimClientAsync {
|
|
nvim: Arc::new(Mutex::new(None)),
|
|
}
|
|
}
|
|
|
|
pub fn borrow(&self) -> Option<NeovimRef> {
|
|
NeovimRef::from_nvim_async(self)
|
|
}
|
|
}
|
|
|
|
impl Clone for NeovimClientAsync {
|
|
fn clone(&self) -> Self {
|
|
NeovimClientAsync {
|
|
nvim: self.nvim.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct NeovimClient {
|
|
state: Cell<NeovimClientState>,
|
|
nvim: RefCell<Option<Neovim>>,
|
|
nvim_async: NeovimClientAsync,
|
|
}
|
|
|
|
impl NeovimClient {
|
|
pub fn new() -> Self {
|
|
NeovimClient {
|
|
state: Cell::new(NeovimClientState::Uninitialized),
|
|
nvim: RefCell::new(None),
|
|
nvim_async: NeovimClientAsync::new(),
|
|
}
|
|
}
|
|
|
|
pub fn clear(&self) {
|
|
let mut nvim = self.nvim.borrow_mut();
|
|
if nvim.is_some() {
|
|
nvim.take();
|
|
} else {
|
|
self.nvim_async.nvim.lock().unwrap().take();
|
|
}
|
|
}
|
|
|
|
pub fn async_to_sync(&self) {
|
|
let mut lock = self.nvim_async.nvim.lock().unwrap();
|
|
let nvim = lock.take().unwrap();
|
|
*self.nvim.borrow_mut() = Some(nvim);
|
|
}
|
|
|
|
pub fn set_nvim_async(&self, nvim: Neovim) -> NeovimClientAsync {
|
|
*self.nvim_async.nvim.lock().unwrap() = Some(nvim);
|
|
self.nvim_async.clone()
|
|
}
|
|
|
|
pub fn set_initialized(&self) {
|
|
self.state.set(NeovimClientState::Initialized);
|
|
}
|
|
|
|
pub fn set_error(&self) {
|
|
self.state.set(NeovimClientState::Error);
|
|
}
|
|
|
|
pub fn set_in_progress(&self) {
|
|
self.state.set(NeovimClientState::InitInProgress);
|
|
}
|
|
|
|
pub fn is_initialized(&self) -> bool {
|
|
self.state.get() == NeovimClientState::Initialized
|
|
}
|
|
|
|
pub fn is_uninitialized(&self) -> bool {
|
|
self.state.get() == NeovimClientState::Uninitialized
|
|
}
|
|
|
|
pub fn is_initializing(&self) -> bool {
|
|
self.state.get() == NeovimClientState::InitInProgress
|
|
}
|
|
|
|
pub fn nvim(&self) -> Option<NeovimRef> {
|
|
let nvim = self.nvim.borrow_mut();
|
|
if nvim.is_some() {
|
|
Some(NeovimRef::from_nvim(RefMut::map(nvim, |n| {
|
|
n.as_mut().unwrap()
|
|
})))
|
|
} else {
|
|
self.nvim_async.borrow()
|
|
}
|
|
}
|
|
}
|