1use crate::Direction;
  2use gpui::{AppContext, Model, ModelContext};
  3use language::Buffer;
  4
  5pub trait InlineCompletionProvider: 'static + Sized {
  6    fn is_enabled(
  7        &self,
  8        buffer: &Model<Buffer>,
  9        cursor_position: language::Anchor,
 10        cx: &AppContext,
 11    ) -> bool;
 12    fn refresh(
 13        &mut self,
 14        buffer: Model<Buffer>,
 15        cursor_position: language::Anchor,
 16        debounce: bool,
 17        cx: &mut ModelContext<Self>,
 18    );
 19    fn cycle(
 20        &mut self,
 21        buffer: Model<Buffer>,
 22        cursor_position: language::Anchor,
 23        direction: Direction,
 24        cx: &mut ModelContext<Self>,
 25    );
 26    fn accept(&mut self, cx: &mut ModelContext<Self>);
 27    fn discard(&mut self, cx: &mut ModelContext<Self>);
 28    fn active_completion_text<'a>(
 29        &'a self,
 30        buffer: &Model<Buffer>,
 31        cursor_position: language::Anchor,
 32        cx: &'a AppContext,
 33    ) -> Option<&str>;
 34}
 35
 36pub trait InlineCompletionProviderHandle {
 37    fn is_enabled(
 38        &self,
 39        buffer: &Model<Buffer>,
 40        cursor_position: language::Anchor,
 41        cx: &AppContext,
 42    ) -> bool;
 43    fn refresh(
 44        &self,
 45        buffer: Model<Buffer>,
 46        cursor_position: language::Anchor,
 47        debounce: bool,
 48        cx: &mut AppContext,
 49    );
 50    fn cycle(
 51        &self,
 52        buffer: Model<Buffer>,
 53        cursor_position: language::Anchor,
 54        direction: Direction,
 55        cx: &mut AppContext,
 56    );
 57    fn accept(&self, cx: &mut AppContext);
 58    fn discard(&self, cx: &mut AppContext);
 59    fn active_completion_text<'a>(
 60        &'a self,
 61        buffer: &Model<Buffer>,
 62        cursor_position: language::Anchor,
 63        cx: &'a AppContext,
 64    ) -> Option<&'a str>;
 65}
 66
 67impl<T> InlineCompletionProviderHandle for Model<T>
 68where
 69    T: InlineCompletionProvider,
 70{
 71    fn is_enabled(
 72        &self,
 73        buffer: &Model<Buffer>,
 74        cursor_position: language::Anchor,
 75        cx: &AppContext,
 76    ) -> bool {
 77        self.read(cx).is_enabled(buffer, cursor_position, cx)
 78    }
 79
 80    fn refresh(
 81        &self,
 82        buffer: Model<Buffer>,
 83        cursor_position: language::Anchor,
 84        debounce: bool,
 85        cx: &mut AppContext,
 86    ) {
 87        self.update(cx, |this, cx| {
 88            this.refresh(buffer, cursor_position, debounce, cx)
 89        })
 90    }
 91
 92    fn cycle(
 93        &self,
 94        buffer: Model<Buffer>,
 95        cursor_position: language::Anchor,
 96        direction: Direction,
 97        cx: &mut AppContext,
 98    ) {
 99        self.update(cx, |this, cx| {
100            this.cycle(buffer, cursor_position, direction, cx)
101        })
102    }
103
104    fn accept(&self, cx: &mut AppContext) {
105        self.update(cx, |this, cx| this.accept(cx))
106    }
107
108    fn discard(&self, cx: &mut AppContext) {
109        self.update(cx, |this, cx| this.discard(cx))
110    }
111
112    fn active_completion_text<'a>(
113        &'a self,
114        buffer: &Model<Buffer>,
115        cursor_position: language::Anchor,
116        cx: &'a AppContext,
117    ) -> Option<&'a str> {
118        self.read(cx)
119            .active_completion_text(buffer, cursor_position, cx)
120    }
121}