Skip to content

Commit ab12e97

Browse files
bokuwebbokuweb
authored
chore: rename (#169)
1 parent 0824f23 commit ab12e97

File tree

5 files changed

+71
-93
lines changed

5 files changed

+71
-93
lines changed

‎raiden-derive/src/condition/builder.rs‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -33,42 +33,42 @@ pub fn expand_condition_builder(
3333
self.not = true;
3434
self
3535
}
36-
pub fn attr_exists(self, field: #attr_enum_name) -> ::raiden::ConditionFilledOrWaitConjunction<#condition_token_name> {
36+
pub fn attr_exists(self, field: #attr_enum_name) -> ::raiden::ConditionFilledOrWaitOperator<#condition_token_name> {
3737
let cond = ::raiden::condition::Cond::Func(::raiden::condition::ConditionFunctionExpression::AttributeExists(field.into_attr_name()));
38-
::raiden::ConditionFilledOrWaitConjunction {
38+
::raiden::ConditionFilledOrWaitOperator {
3939
not: self.not,
4040
cond,
4141
_token: std::marker::PhantomData,
4242
}
4343
}
44-
pub fn attr_not_exists(self, field: #attr_enum_name) -> ::raiden::ConditionFilledOrWaitConjunction<#condition_token_name> {
44+
pub fn attr_not_exists(self, field: #attr_enum_name) -> ::raiden::ConditionFilledOrWaitOperator<#condition_token_name> {
4545
let cond = ::raiden::condition::Cond::Func(::raiden::condition::ConditionFunctionExpression::AttributeNotExists(field.into_attr_name()));
46-
::raiden::ConditionFilledOrWaitConjunction {
46+
::raiden::ConditionFilledOrWaitOperator {
4747
not: self.not,
4848
cond,
4949
_token: std::marker::PhantomData,
5050
}
5151
}
52-
pub fn attr_type(self, field: #attr_enum_name, t: ::raiden::AttributeType) -> ::raiden::ConditionFilledOrWaitConjunction<#condition_token_name> {
52+
pub fn attr_type(self, field: #attr_enum_name, t: ::raiden::AttributeType) -> ::raiden::ConditionFilledOrWaitOperator<#condition_token_name> {
5353
let cond = ::raiden::condition::Cond::Func(::raiden::condition::ConditionFunctionExpression::AttributeType(field.into_attr_name(), t));
54-
::raiden::ConditionFilledOrWaitConjunction {
54+
::raiden::ConditionFilledOrWaitOperator {
5555
not: self.not,
5656
cond,
5757
_token: std::marker::PhantomData,
5858
}
5959
}
60-
pub fn begins_with(self, field: #attr_enum_name, s: impl Into<String>) -> ::raiden::ConditionFilledOrWaitConjunction<#condition_token_name> {
60+
pub fn begins_with(self, field: #attr_enum_name, s: impl Into<String>) -> ::raiden::ConditionFilledOrWaitOperator<#condition_token_name> {
6161
let cond = ::raiden::condition::Cond::Func(::raiden::condition::ConditionFunctionExpression::BeginsWith(field.into_attr_name(), s.into()));
62-
::raiden::ConditionFilledOrWaitConjunction {
62+
::raiden::ConditionFilledOrWaitOperator {
6363
not: self.not,
6464
cond,
6565
_token: std::marker::PhantomData,
6666
}
6767
}
6868

69-
pub fn contains(self, field: #attr_enum_name, s: impl Into<String>) -> ::raiden::ConditionFilledOrWaitConjunction<#condition_token_name> {
69+
pub fn contains(self, field: #attr_enum_name, s: impl Into<String>) -> ::raiden::ConditionFilledOrWaitOperator<#condition_token_name> {
7070
let cond = ::raiden::condition::Cond::Func(::raiden::condition::ConditionFunctionExpression::Contains(field.into_attr_name(), s.into()));
71-
::raiden::ConditionFilledOrWaitConjunction {
71+
::raiden::ConditionFilledOrWaitOperator {
7272
not: self.not,
7373
cond,
7474
_token: std::marker::PhantomData,
@@ -100,21 +100,21 @@ pub fn expand_condition_builder(
100100
}
101101

102102
impl #wait_attr_op_name {
103-
pub fn eq_attr(self, attr: #attr_enum_name) -> ::raiden::ConditionFilledOrWaitConjunction<#condition_token_name> {
103+
pub fn eq_attr(self, attr: #attr_enum_name) -> ::raiden::ConditionFilledOrWaitOperator<#condition_token_name> {
104104
let attr = ::raiden::AttrOrPlaceholder::Attr(attr.into_attr_name());
105105
let cond = ::raiden::condition::Cond::Cmp(::raiden::condition::ConditionComparisonExpression::Eq(self.attr_or_placeholder, self.attr_value, attr, None));
106-
::raiden::ConditionFilledOrWaitConjunction {
106+
::raiden::ConditionFilledOrWaitOperator {
107107
not: self.not,
108108
cond,
109109
_token: std::marker::PhantomData,
110110
}
111111

112112
}
113113

114-
pub fn eq_value(self, value: impl ::raiden::IntoAttribute) -> ::raiden::ConditionFilledOrWaitConjunction<#condition_token_name> {
114+
pub fn eq_value(self, value: impl ::raiden::IntoAttribute) -> ::raiden::ConditionFilledOrWaitOperator<#condition_token_name> {
115115
let placeholder = ::raiden::AttrOrPlaceholder::Placeholder(format!("value{}", ::raiden::generate_value_id()));
116116
let cond = ::raiden::condition::Cond::Cmp(::raiden::condition::ConditionComparisonExpression::Eq(self.attr_or_placeholder, self.attr_value, placeholder, Some(value.into_attr())));
117-
::raiden::ConditionFilledOrWaitConjunction {
117+
::raiden::ConditionFilledOrWaitOperator {
118118
not: self.not,
119119
cond,
120120
_token: std::marker::PhantomData,

‎raiden/src/condition/mod.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ pub enum ConditionComparisonExpression {
2424
}
2525

2626
#[derive(Clone, PartialEq)]
27-
pub struct ConditionFilledOrWaitConjunction<T: Clone> {
27+
pub struct ConditionFilledOrWaitOperator<T: Clone> {
2828
pub not: bool,
2929
pub cond: Cond,
3030
pub _token: std::marker::PhantomData<fn() -> T>,
@@ -34,17 +34,17 @@ pub struct ConditionFilledOrWaitConjunction<T: Clone> {
3434
pub struct ConditionFilled<T: Clone> {
3535
pub not: bool,
3636
pub cond: Cond,
37-
pub conjunction: Conjunction,
37+
pub operator: Operator,
3838
pub _token: std::marker::PhantomData<fn() -> T>,
3939
}
4040

41-
impl<T: Clone> ConditionFilledOrWaitConjunction<T> {
41+
impl<T: Clone> ConditionFilledOrWaitOperator<T> {
4242
pub fn and(self, cond: impl ConditionBuilder<T>) -> ConditionFilled<T> {
4343
let (condition_string, attr_names, attr_values) = cond.build();
4444
ConditionFilled {
4545
not: self.not,
4646
cond: self.cond,
47-
conjunction: Conjunction::And(condition_string, attr_names, attr_values),
47+
operator: Operator::And(condition_string, attr_names, attr_values),
4848
_token: self._token,
4949
}
5050
}
@@ -53,13 +53,13 @@ impl<T: Clone> ConditionFilledOrWaitConjunction<T> {
5353
ConditionFilled {
5454
not: self.not,
5555
cond: self.cond,
56-
conjunction: Conjunction::Or(condition_string, attr_names, attr_values),
56+
operator: Operator::Or(condition_string, attr_names, attr_values),
5757
_token: self._token,
5858
}
5959
}
6060
}
6161

62-
impl<T: Clone> ConditionBuilder<T> for ConditionFilledOrWaitConjunction<T> {
62+
impl<T: Clone> ConditionBuilder<T> for ConditionFilledOrWaitOperator<T> {
6363
fn build(self) -> (String, super::AttributeNames, super::AttributeValues) {
6464
if self.not {
6565
(
@@ -78,9 +78,9 @@ impl<T: Clone> ConditionBuilder<T> for ConditionFilledOrWaitConjunction<T> {
7878
}
7979
impl<T: Clone> ConditionBuilder<T> for ConditionFilled<T> {
8080
fn build(self) -> (String, super::AttributeNames, super::AttributeValues) {
81-
let (right_str, right_names, right_values) = match self.conjunction {
82-
super::condition::Conjunction::And(s, m, v) => (format!("AND ({})", s), m, v),
83-
super::condition::Conjunction::Or(s, m, v) => (format!("OR ({})", s), m, v),
81+
let (right_str, right_names, right_values) = match self.operator {
82+
super::condition::Operator::And(s, m, v) => (format!("AND ({})", s), m, v),
83+
super::condition::Operator::Or(s, m, v) => (format!("OR ({})", s), m, v),
8484
};
8585
let left_str = self.cond.to_string();
8686
let left_names = self.cond.to_attr_names();
@@ -249,7 +249,7 @@ impl std::string::ToString for AttrOrPlaceholder {
249249
pub type ConditionString = String;
250250

251251
#[derive(Debug, Clone, PartialEq)]
252-
pub enum Conjunction {
252+
pub enum Operator {
253253
And(
254254
ConditionString,
255255
super::AttributeNames,

‎raiden/src/filter_expression/mod.rs‎

Lines changed: 24 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ pub type FilterExpressionString = String;
44
// Filter expressions can use the same comparators, functions, and logical operators as a key condition expression, with the addition of the not-equals operator (<>).
55
// ref: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html
66
#[derive(Debug, Clone)]
7-
pub enum FilterExpressionConjunction {
7+
pub enum FilterExpressionOperator {
88
And(
99
FilterExpressionString,
1010
super::AttributeNames,
@@ -47,7 +47,7 @@ pub struct FilterExpression<T> {
4747
}
4848

4949
#[derive(Debug, Clone)]
50-
pub struct FilterExpressionFilledOrWaitConjunction<T> {
50+
pub struct FilterExpressionFilledOrWaitOperator<T> {
5151
attr: String,
5252
cond: FilterExpressionTypes,
5353
_token: std::marker::PhantomData<fn() -> T>,
@@ -57,27 +57,23 @@ pub struct FilterExpressionFilledOrWaitConjunction<T> {
5757
pub struct FilterExpressionFilled<T> {
5858
attr: String,
5959
cond: FilterExpressionTypes,
60-
conjunction: FilterExpressionConjunction,
60+
operator: FilterExpressionOperator,
6161
_token: std::marker::PhantomData<fn() -> T>,
6262
}
6363

64-
impl<T> FilterExpressionFilledOrWaitConjunction<T> {
64+
impl<T> FilterExpressionFilledOrWaitOperator<T> {
6565
pub fn and(self, cond: impl FilterExpressionBuilder<T>) -> FilterExpressionFilled<T> {
6666
let (condition_string, attr_names, attr_values) = cond.build();
6767
FilterExpressionFilled {
6868
attr: self.attr,
6969
cond: self.cond,
70-
conjunction: FilterExpressionConjunction::And(
71-
condition_string,
72-
attr_names,
73-
attr_values,
74-
),
70+
operator: FilterExpressionOperator::And(condition_string, attr_names, attr_values),
7571
_token: self._token,
7672
}
7773
}
7874
}
7975

80-
impl<T> FilterExpressionBuilder<T> for FilterExpressionFilledOrWaitConjunction<T> {
76+
impl<T> FilterExpressionBuilder<T> for FilterExpressionFilledOrWaitOperator<T> {
8177
fn build(self) -> (String, super::AttributeNames, super::AttributeValues) {
8278
let attr_name = self.attr;
8379
let mut attr_names: super::AttributeNames = std::collections::HashMap::new();
@@ -159,8 +155,8 @@ impl<T> FilterExpressionBuilder<T> for FilterExpressionFilledOrWaitConjunction<T
159155

160156
impl<T> FilterExpressionBuilder<T> for FilterExpressionFilled<T> {
161157
fn build(self) -> (String, super::AttributeNames, super::AttributeValues) {
162-
let (right_str, right_names, right_values) = match self.conjunction {
163-
FilterExpressionConjunction::And(s, m, v) => (format!("AND ({})", s), m, v),
158+
let (right_str, right_names, right_values) = match self.operator {
159+
FilterExpressionOperator::And(s, m, v) => (format!("AND ({})", s), m, v),
164160
};
165161

166162
let attr_name = self.attr;
@@ -215,77 +211,59 @@ impl<T> FilterExpressionBuilder<T> for FilterExpressionFilled<T> {
215211
}
216212

217213
impl<T> FilterExpression<T> {
218-
pub fn eq(
219-
self,
220-
value: impl super::IntoAttribute,
221-
) -> FilterExpressionFilledOrWaitConjunction<T> {
214+
pub fn eq(self, value: impl super::IntoAttribute) -> FilterExpressionFilledOrWaitOperator<T> {
222215
let placeholder = format!(":value{}", super::generate_value_id());
223216
let cond = FilterExpressionTypes::Eq(placeholder, value.into_attr());
224-
FilterExpressionFilledOrWaitConjunction {
217+
FilterExpressionFilledOrWaitOperator {
225218
attr: self.attr,
226219
cond,
227220
_token: std::marker::PhantomData,
228221
}
229222
}
230223

231-
pub fn not(
232-
self,
233-
value: impl super::IntoAttribute,
234-
) -> FilterExpressionFilledOrWaitConjunction<T> {
224+
pub fn not(self, value: impl super::IntoAttribute) -> FilterExpressionFilledOrWaitOperator<T> {
235225
let placeholder = format!(":value{}", super::generate_value_id());
236226
let cond = FilterExpressionTypes::Not(placeholder, value.into_attr());
237-
FilterExpressionFilledOrWaitConjunction {
227+
FilterExpressionFilledOrWaitOperator {
238228
attr: self.attr,
239229
cond,
240230
_token: std::marker::PhantomData,
241231
}
242232
}
243233

244-
pub fn gt(
245-
self,
246-
value: impl super::IntoAttribute,
247-
) -> FilterExpressionFilledOrWaitConjunction<T> {
234+
pub fn gt(self, value: impl super::IntoAttribute) -> FilterExpressionFilledOrWaitOperator<T> {
248235
let placeholder = format!(":value{}", super::generate_value_id());
249236
let cond = FilterExpressionTypes::Gt(placeholder, value.into_attr());
250-
FilterExpressionFilledOrWaitConjunction {
237+
FilterExpressionFilledOrWaitOperator {
251238
attr: self.attr,
252239
cond,
253240
_token: std::marker::PhantomData,
254241
}
255242
}
256-
pub fn ge(
257-
self,
258-
value: impl super::IntoAttribute,
259-
) -> FilterExpressionFilledOrWaitConjunction<T> {
243+
pub fn ge(self, value: impl super::IntoAttribute) -> FilterExpressionFilledOrWaitOperator<T> {
260244
let placeholder = format!(":value{}", super::generate_value_id());
261245
let cond = FilterExpressionTypes::Ge(placeholder, value.into_attr());
262-
FilterExpressionFilledOrWaitConjunction {
246+
FilterExpressionFilledOrWaitOperator {
263247
attr: self.attr,
264248
cond,
265249
_token: std::marker::PhantomData,
266250
}
267251
}
268252

269-
pub fn le(
270-
self,
271-
value: impl super::IntoAttribute,
272-
) -> FilterExpressionFilledOrWaitConjunction<T> {
253+
pub fn le(self, value: impl super::IntoAttribute) -> FilterExpressionFilledOrWaitOperator<T> {
273254
let placeholder = format!(":value{}", super::generate_value_id());
274255
let cond = FilterExpressionTypes::Le(placeholder, value.into_attr());
275-
FilterExpressionFilledOrWaitConjunction {
256+
FilterExpressionFilledOrWaitOperator {
276257
attr: self.attr,
277258
cond,
278259
_token: std::marker::PhantomData,
279260
}
280261
}
281262

282-
pub fn lt(
283-
self,
284-
value: impl super::IntoAttribute,
285-
) -> FilterExpressionFilledOrWaitConjunction<T> {
263+
pub fn lt(self, value: impl super::IntoAttribute) -> FilterExpressionFilledOrWaitOperator<T> {
286264
let placeholder = format!(":value{}", super::generate_value_id());
287265
let cond = FilterExpressionTypes::Lt(placeholder, value.into_attr());
288-
FilterExpressionFilledOrWaitConjunction {
266+
FilterExpressionFilledOrWaitOperator {
289267
attr: self.attr,
290268
cond,
291269
_token: std::marker::PhantomData,
@@ -296,7 +274,7 @@ impl<T> FilterExpression<T> {
296274
self,
297275
value1: impl super::IntoAttribute,
298276
value2: impl super::IntoAttribute,
299-
) -> FilterExpressionFilledOrWaitConjunction<T> {
277+
) -> FilterExpressionFilledOrWaitOperator<T> {
300278
let placeholder1 = format!(":value{}", super::generate_value_id());
301279
let placeholder2 = format!(":value{}", super::generate_value_id());
302280
let cond = FilterExpressionTypes::Between(
@@ -305,7 +283,7 @@ impl<T> FilterExpression<T> {
305283
placeholder2,
306284
value2.into_attr(),
307285
);
308-
FilterExpressionFilledOrWaitConjunction {
286+
FilterExpressionFilledOrWaitOperator {
309287
attr: self.attr,
310288
cond,
311289
_token: std::marker::PhantomData,
@@ -316,10 +294,10 @@ impl<T> FilterExpression<T> {
316294
pub fn begins_with(
317295
self,
318296
value: impl super::IntoAttribute,
319-
) -> FilterExpressionFilledOrWaitConjunction<T> {
297+
) -> FilterExpressionFilledOrWaitOperator<T> {
320298
let placeholder = format!(":value{}", super::generate_value_id());
321299
let cond = FilterExpressionTypes::BeginsWith(placeholder, value.into_attr());
322-
FilterExpressionFilledOrWaitConjunction {
300+
FilterExpressionFilledOrWaitOperator {
323301
attr: self.attr,
324302
cond,
325303
_token: std::marker::PhantomData,

0 commit comments

Comments
 (0)