os_query_builder_rs/term/
regexp.rs

1use serde::{
2    Serialize,
3    Serializer,
4    ser::SerializeMap
5};
6use crate::misc::{
7    rewrite::Rewrite,
8    regexp_flag::RegexpFlag
9};
10
11#[derive(Debug, Default, Clone)]
12pub struct Regexp {
13    field: Option<String>,
14    value: RegexpValue
15}
16
17#[derive(Debug, Default, Clone, Serialize)]
18struct RegexpValue {
19    value: String,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    boost: Option<f64>,
22    #[serde(skip_serializing_if = "Option::is_none")]
23    case_insensitive: Option<bool>,
24    #[serde(skip_serializing_if = "Option::is_none")]
25    flags: Option<RegexpFlag>,
26    #[serde(skip_serializing_if = "Option::is_none")]
27    max_determinized_states: Option<u64>,
28    #[serde(skip_serializing_if = "Option::is_none")]
29    rewrite: Option<Rewrite>
30}
31
32impl Serialize for Regexp {
33    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
34        where
35            S: Serializer,
36    {
37        let mut state = serializer.serialize_map(Some(1))?;
38        state.serialize_entry(&self.field.as_deref().unwrap_or_default(), &self.value)?;
39        state.end()
40    }
41}
42
43
44impl Regexp {
45    pub fn new() -> Self {
46        Self::default()
47    }
48
49    pub fn field<T:Into<String>+Serialize>(self, field: T) -> Self {
50        Self {
51            field: Some(field.into()),
52            ..self
53        }
54    }
55
56    pub fn value<T:Into<String>+Serialize>(self, value: T) -> Self {
57        Self {
58            value: RegexpValue {
59                value: value.into(),
60                ..self.value
61            },
62            ..self
63        }
64    }
65
66    pub fn boost<T:Into<f64>+Serialize>(self, boost: T) -> Self {
67        Self {
68            value: RegexpValue {
69                boost: Some(boost.into()),
70                ..self.value
71            },
72            ..self
73        }
74    }
75
76    pub fn case_insensitive<T:Into<bool>+Serialize>(self, case_insensitive: T) -> Self {
77        Self {
78            value: RegexpValue {
79                case_insensitive: Some(case_insensitive.into()),
80                ..self.value
81            },
82            ..self
83        }
84    }
85
86    pub fn max_determinized_states<T:Into<u64>+Serialize>(self, max_determinized_states: T) -> Self {
87        Self {
88            value: RegexpValue {
89                max_determinized_states: Some(max_determinized_states.into()),
90                ..self.value
91            },
92            ..self
93        }
94    }
95
96    pub fn rewrite<T:Into<Rewrite>+Serialize>(self, rewrite: T) -> Self {
97        Self {
98            value: RegexpValue {
99                rewrite: Some(rewrite.into()),
100                ..self.value
101            },
102            ..self
103        }
104    }
105
106    pub fn flags<T:Into<RegexpFlag>+Serialize>(self, flags: T) -> Self {
107        Self {
108            value: RegexpValue {
109                flags: Some(flags.into()),
110                ..self.value
111            },
112            ..self
113        }
114    }
115}
os_query_builder_rs/term/regexp.rs

os_query_builder_rs/term/
regexp.rs
