1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use super::*;

// mod operator; pub use operator::Operator;
pub mod generic; // pub use equal::Equal;
pub use generic::{Operator, Filter};
mod and; pub use and::And;
mod or;  pub use or::Or;

pub trait FilterTrait {
  fn filter(&self) -> String;
}

pub struct Filterable<T> 
where T: FilterTrait
{
  filter: Option<T>,
  next: Option<Box<dyn Selectable>>,
}

impl<T> std::convert::From<()> for Filterable<T>
where T: FilterTrait
{
  fn from(_: ()) -> Self {
    Filterable { filter: None, next: None }
  }
}

impl<T> std::convert::From<T> for Filterable<T> 
where T: FilterTrait
{
  fn from(v: T) -> Self { 
    Filterable { filter: Some(v), next: None }
  }
}

impl<T> Filterable<T> 
where T: FilterTrait
{
  pub fn and(mut self, next: Box<dyn Selectable>) -> Filterable<T> {
    self.next = Some(next);
    self
  }

  pub fn next(&self) -> &Option<Box<dyn Selectable>> { &self.next }
}

/*
pub trait Filterable {
  fn filter(&self) -> Option<String>;
  fn next(&self) -> &Option<Box<dyn Selectable>>;
  fn and(self, next: Box<dyn Selectable>) -> Self;
}
*/

impl<T> Selectable for Filterable<T>
where T: FilterTrait
{
  fn filter(&self)   -> Option<String> { 
    self.filter.as_ref().map(|f| f.filter())
  }

  fn limit(&self)    -> Option<usize>  { self.next.as_ref().and_then(|n| n.limit()) }
  fn offset(&self)   -> Option<usize>  { self.next.as_ref().and_then(|n| n.offset()) }
  fn order_by(&self) -> Option<String> { self.next.as_ref().and_then(|n| n.order_by()) }
}