blob: 58b37fae0ee7f5bfac48e7bab2eb5a8456205dc0 (
plain)
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
#import "NSComparisonPredicate+MGLAdditions.h"
#import "NSPredicate+MGLAdditions.h"
#import "NSExpression+MGLAdditions.h"
@implementation NSComparisonPredicate (MGLAdditions)
- (mbgl::style::Filter)mgl_filter
{
NSExpression *leftExpression = self.leftExpression;
NSExpression *rightExpression = self.rightExpression;
NSExpressionType leftType = leftExpression.expressionType;
NSExpressionType rightType = rightExpression.expressionType;
BOOL isReversed = ((leftType == NSConstantValueExpressionType || leftType == NSAggregateExpressionType)
&& rightType == NSKeyPathExpressionType);
switch (self.predicateOperatorType) {
case NSEqualToPredicateOperatorType: {
mbgl::style::EqualsFilter eqFilter;
eqFilter.key = self.mgl_keyPath.UTF8String;
eqFilter.value = self.mgl_constantValue;
// Convert == nil to NotHasFilter.
if (eqFilter.value.is<mbgl::NullValue>()) {
mbgl::style::NotHasFilter notHasFilter;
notHasFilter.key = eqFilter.key;
return notHasFilter;
}
return eqFilter;
}
case NSNotEqualToPredicateOperatorType: {
mbgl::style::NotEqualsFilter neFilter;
neFilter.key = self.mgl_keyPath.UTF8String;
neFilter.value = self.mgl_constantValue;
// Convert != nil to HasFilter.
if (neFilter.value.is<mbgl::NullValue>()) {
mbgl::style::HasFilter hasFilter;
hasFilter.key = neFilter.key;
return hasFilter;
}
return neFilter;
}
case NSGreaterThanPredicateOperatorType: {
if (isReversed) {
mbgl::style::LessThanFilter ltFilter;
ltFilter.key = self.mgl_keyPath.UTF8String;
ltFilter.value = self.mgl_constantValue;
return ltFilter;
} else {
mbgl::style::GreaterThanFilter gtFilter;
gtFilter.key = self.mgl_keyPath.UTF8String;
gtFilter.value = self.mgl_constantValue;
return gtFilter;
}
}
case NSGreaterThanOrEqualToPredicateOperatorType: {
if (isReversed) {
mbgl::style::LessThanEqualsFilter lteFilter;
lteFilter.key = self.mgl_keyPath.UTF8String;
lteFilter.value = self.mgl_constantValue;
return lteFilter;
} else {
mbgl::style::GreaterThanEqualsFilter gteFilter;
gteFilter.key = self.mgl_keyPath.UTF8String;
gteFilter.value = self.mgl_constantValue;
return gteFilter;
}
}
case NSLessThanPredicateOperatorType: {
if (isReversed) {
mbgl::style::GreaterThanFilter gtFilter;
gtFilter.key = self.mgl_keyPath.UTF8String;
gtFilter.value = self.mgl_constantValue;
return gtFilter;
} else {
mbgl::style::LessThanFilter ltFilter;
ltFilter.key = self.mgl_keyPath.UTF8String;
ltFilter.value = self.mgl_constantValue;
return ltFilter;
}
}
case NSLessThanOrEqualToPredicateOperatorType: {
if (isReversed) {
mbgl::style::GreaterThanEqualsFilter gteFilter;
gteFilter.key = self.mgl_keyPath.UTF8String;
gteFilter.value = self.mgl_constantValue;
return gteFilter;
} else {
mbgl::style::LessThanEqualsFilter lteFilter;
lteFilter.key = self.mgl_keyPath.UTF8String;
lteFilter.value = self.mgl_constantValue;
return lteFilter;
}
}
case NSInPredicateOperatorType: {
if (isReversed) {
if (leftType == NSConstantValueExpressionType && [leftExpression.constantValue isKindOfClass:[NSString class]]) {
[NSException raise:NSInvalidArgumentException
format:@"CONTAINS not supported for string comparison."];
}
[NSException raise:NSInvalidArgumentException
format:@"Predicate cannot compare values IN attribute."];
}
mbgl::style::InFilter inFilter;
inFilter.key = leftExpression.keyPath.UTF8String;
inFilter.values = rightExpression.mgl_aggregateMBGLValue;
return inFilter;
}
case NSContainsPredicateOperatorType: {
if (!isReversed) {
if (rightType == NSConstantValueExpressionType && [rightExpression.constantValue isKindOfClass:[NSString class]]) {
[NSException raise:NSInvalidArgumentException
format:@"IN not supported for string comparison."];
}
[NSException raise:NSInvalidArgumentException
format:@"Predicate cannot compare attribute CONTAINS values."];
}
mbgl::style::InFilter inFilter;
inFilter.key = rightExpression.keyPath.UTF8String;
inFilter.values = leftExpression.mgl_aggregateMBGLValue;
return inFilter;
}
case NSBetweenPredicateOperatorType: {
if (isReversed) {
[NSException raise:NSInvalidArgumentException
format:@"Predicate cannot compare bounds BETWEEN attribute."];
}
if (![rightExpression.constantValue isKindOfClass:[NSArray class]]) {
[NSException raise:NSInvalidArgumentException
format:@"Right side of BETWEEN predicate must be an array."]; // not NSSet
}
auto values = rightExpression.mgl_aggregateMBGLValue;
if (values.size() != 2) {
[NSException raise:NSInvalidArgumentException
format:@"Right side of BETWEEN predicate must have two items."];
}
mbgl::style::AllFilter allFilter;
mbgl::style::GreaterThanEqualsFilter gteFilter;
gteFilter.key = leftExpression.keyPath.UTF8String;
gteFilter.value = values[0];
allFilter.filters.push_back(gteFilter);
mbgl::style::LessThanEqualsFilter lteFilter;
lteFilter.key = leftExpression.keyPath.UTF8String;
lteFilter.value = values[1];
allFilter.filters.push_back(lteFilter);
return allFilter;
}
case NSMatchesPredicateOperatorType:
case NSLikePredicateOperatorType:
case NSBeginsWithPredicateOperatorType:
case NSEndsWithPredicateOperatorType:
case NSCustomSelectorPredicateOperatorType:
[NSException raise:NSInvalidArgumentException
format:@"NSPredicateOperatorType:%lu is not supported.", (unsigned long)self.predicateOperatorType];
}
return {};
}
- (NSString *)mgl_keyPath {
NSExpression *leftExpression = self.leftExpression;
NSExpression *rightExpression = self.rightExpression;
NSExpressionType leftType = leftExpression.expressionType;
NSExpressionType rightType = rightExpression.expressionType;
if (leftType == NSKeyPathExpressionType && rightType == NSConstantValueExpressionType) {
return leftExpression.keyPath;
} else if (leftType == NSConstantValueExpressionType && rightType == NSKeyPathExpressionType) {
return rightExpression.keyPath;
}
[NSException raise:NSInvalidArgumentException
format:@"Comparison predicate must compare an attribute (as a key path) to a constant or vice versa."];
return nil;
}
- (mbgl::Value)mgl_constantValue {
NSExpression *leftExpression = self.leftExpression;
NSExpression *rightExpression = self.rightExpression;
NSExpressionType leftType = leftExpression.expressionType;
NSExpressionType rightType = rightExpression.expressionType;
mbgl::Value value;
if (leftType == NSKeyPathExpressionType && rightType == NSConstantValueExpressionType) {
value = rightExpression.mgl_constantMBGLValue;
} else if (leftType == NSConstantValueExpressionType && rightType == NSKeyPathExpressionType) {
value = leftExpression.mgl_constantMBGLValue;
} else {
[NSException raise:NSInvalidArgumentException
format:@"Comparison predicate must compare an attribute (as a key path) to a constant or vice versa."];
}
return value;
}
@end
|
