notedeck

One damus client to rule them all
git clone git://jb55.com/notedeck
Log | Files | Refs | README | LICENSE

thread.rs (2276B)

      1 use crate::{
      2     multi_subscriber::MultiSubscriber,
      3     notes_holder::NotesHolder,
      4     timeline::{TimelineTab, ViewFilter},
      5 };
      6 
      7 use nostrdb::{Filter, FilterBuilder, Ndb, Transaction};
      8 use notedeck::{MuteFun, NoteCache, NoteRef};
      9 
     10 #[derive(Default)]
     11 pub struct Thread {
     12     view: TimelineTab,
     13     pub multi_subscriber: Option<MultiSubscriber>,
     14 }
     15 
     16 impl Thread {
     17     pub fn new(notes: Vec<NoteRef>) -> Self {
     18         let mut cap = ((notes.len() as f32) * 1.5) as usize;
     19         if cap == 0 {
     20             cap = 25;
     21         }
     22         let mut view = TimelineTab::new_with_capacity(ViewFilter::NotesAndReplies, cap);
     23         view.notes = notes;
     24 
     25         Thread {
     26             view,
     27             multi_subscriber: None,
     28         }
     29     }
     30 
     31     pub fn view(&self) -> &TimelineTab {
     32         &self.view
     33     }
     34 
     35     pub fn view_mut(&mut self) -> &mut TimelineTab {
     36         &mut self.view
     37     }
     38 
     39     fn filters_raw(root: &[u8; 32]) -> Vec<FilterBuilder> {
     40         vec![
     41             nostrdb::Filter::new().kinds([1]).event(root),
     42             nostrdb::Filter::new().ids([root]).limit(1),
     43         ]
     44     }
     45 
     46     pub fn filters_since(root: &[u8; 32], since: u64) -> Vec<Filter> {
     47         Self::filters_raw(root)
     48             .into_iter()
     49             .map(|fb| fb.since(since).build())
     50             .collect()
     51     }
     52 
     53     pub fn filters(root: &[u8; 32]) -> Vec<Filter> {
     54         Self::filters_raw(root)
     55             .into_iter()
     56             .map(|mut fb| fb.build())
     57             .collect()
     58     }
     59 }
     60 
     61 impl NotesHolder for Thread {
     62     fn get_multi_subscriber(&mut self) -> Option<&mut MultiSubscriber> {
     63         self.multi_subscriber.as_mut()
     64     }
     65 
     66     fn filters(for_id: &[u8; 32]) -> Vec<Filter> {
     67         Thread::filters(for_id)
     68     }
     69 
     70     fn new_notes_holder(
     71         _: &Transaction,
     72         _: &Ndb,
     73         _: &mut NoteCache,
     74         _: &[u8; 32],
     75         _: Vec<Filter>,
     76         notes: Vec<NoteRef>,
     77         _: &MuteFun,
     78     ) -> Self {
     79         Thread::new(notes)
     80     }
     81 
     82     fn get_view(&mut self) -> &mut TimelineTab {
     83         &mut self.view
     84     }
     85 
     86     fn filters_since(for_id: &[u8; 32], since: u64) -> Vec<Filter> {
     87         Thread::filters_since(for_id, since)
     88     }
     89 
     90     fn set_multi_subscriber(&mut self, subscriber: MultiSubscriber) {
     91         self.multi_subscriber = Some(subscriber);
     92     }
     93 }