diff options
author | Kelly Rauchenberger <fefferburbia@gmail.com> | 2017-01-23 11:20:20 -0500 |
---|---|---|
committer | Kelly Rauchenberger <fefferburbia@gmail.com> | 2017-01-23 11:20:20 -0500 |
commit | d19c329607d611901540e5d3d746c1a94a0b6210 (patch) | |
tree | 05c845164e3f3df9dc38668a0278d15d0caaacfe | |
parent | 71064d07ad84b1d31471298f8cc5b497cbe85505 (diff) | |
download | verbly-d19c329607d611901540e5d3d746c1a94a0b6210.tar.gz verbly-d19c329607d611901540e5d3d746c1a94a0b6210.tar.bz2 verbly-d19c329607d611901540e5d3d746c1a94a0b6210.zip |
Fixed normalization of negative join filters
Previously, negative join filters were folded in with positive joins by AND/ORing them together and negating the negative joins. Checking for the existence of something that doesn't match a condition is different from checking for the non-existence of something that does match a condition, so now normalization considers positive and negative join filters to be distinct classes of filters and does not fold them together. Also made some whitespace changes.
-rw-r--r-- | lib/filter.cpp | 375 |
1 files changed, 192 insertions, 183 deletions
diff --git a/lib/filter.cpp b/lib/filter.cpp index 959fa05..1af7314 100644 --- a/lib/filter.cpp +++ b/lib/filter.cpp | |||
@@ -14,19 +14,19 @@ namespace verbly { | |||
14 | filter::filter(const filter& other) | 14 | filter::filter(const filter& other) |
15 | { | 15 | { |
16 | type_ = other.type_; | 16 | type_ = other.type_; |
17 | 17 | ||
18 | switch (type_) | 18 | switch (type_) |
19 | { | 19 | { |
20 | case type::empty: | 20 | case type::empty: |
21 | { | 21 | { |
22 | break; | 22 | break; |
23 | } | 23 | } |
24 | 24 | ||
25 | case type::singleton: | 25 | case type::singleton: |
26 | { | 26 | { |
27 | new(&singleton_.filterField) field(other.singleton_.filterField); | 27 | new(&singleton_.filterField) field(other.singleton_.filterField); |
28 | singleton_.filterType = other.singleton_.filterType; | 28 | singleton_.filterType = other.singleton_.filterType; |
29 | 29 | ||
30 | switch (singleton_.filterType) | 30 | switch (singleton_.filterType) |
31 | { | 31 | { |
32 | case comparison::int_equals: | 32 | case comparison::int_equals: |
@@ -37,74 +37,74 @@ namespace verbly { | |||
37 | case comparison::int_is_less_than: | 37 | case comparison::int_is_less_than: |
38 | { | 38 | { |
39 | singleton_.intValue = other.singleton_.intValue; | 39 | singleton_.intValue = other.singleton_.intValue; |
40 | 40 | ||
41 | break; | 41 | break; |
42 | } | 42 | } |
43 | 43 | ||
44 | case comparison::boolean_equals: | 44 | case comparison::boolean_equals: |
45 | { | 45 | { |
46 | singleton_.boolValue = other.singleton_.boolValue; | 46 | singleton_.boolValue = other.singleton_.boolValue; |
47 | 47 | ||
48 | break; | 48 | break; |
49 | } | 49 | } |
50 | 50 | ||
51 | case comparison::string_equals: | 51 | case comparison::string_equals: |
52 | case comparison::string_does_not_equal: | 52 | case comparison::string_does_not_equal: |
53 | case comparison::string_is_like: | 53 | case comparison::string_is_like: |
54 | case comparison::string_is_not_like: | 54 | case comparison::string_is_not_like: |
55 | { | 55 | { |
56 | new(&singleton_.stringValue) std::string(other.singleton_.stringValue); | 56 | new(&singleton_.stringValue) std::string(other.singleton_.stringValue); |
57 | 57 | ||
58 | break; | 58 | break; |
59 | } | 59 | } |
60 | 60 | ||
61 | case comparison::is_null: | 61 | case comparison::is_null: |
62 | case comparison::is_not_null: | 62 | case comparison::is_not_null: |
63 | { | 63 | { |
64 | break; | 64 | break; |
65 | } | 65 | } |
66 | 66 | ||
67 | case comparison::matches: | 67 | case comparison::matches: |
68 | case comparison::does_not_match: | 68 | case comparison::does_not_match: |
69 | case comparison::hierarchally_matches: | 69 | case comparison::hierarchally_matches: |
70 | case comparison::does_not_hierarchally_match: | 70 | case comparison::does_not_hierarchally_match: |
71 | { | 71 | { |
72 | new(&singleton_.join) std::unique_ptr<filter>(new filter(*other.singleton_.join)); | 72 | new(&singleton_.join) std::unique_ptr<filter>(new filter(*other.singleton_.join)); |
73 | 73 | ||
74 | break; | 74 | break; |
75 | } | 75 | } |
76 | } | 76 | } |
77 | 77 | ||
78 | break; | 78 | break; |
79 | } | 79 | } |
80 | 80 | ||
81 | case type::group: | 81 | case type::group: |
82 | { | 82 | { |
83 | new(&group_.children) std::list<filter>(other.group_.children); | 83 | new(&group_.children) std::list<filter>(other.group_.children); |
84 | group_.orlogic = other.group_.orlogic; | 84 | group_.orlogic = other.group_.orlogic; |
85 | 85 | ||
86 | break; | 86 | break; |
87 | } | 87 | } |
88 | } | 88 | } |
89 | } | 89 | } |
90 | 90 | ||
91 | filter::filter(filter&& other) : filter() | 91 | filter::filter(filter&& other) : filter() |
92 | { | 92 | { |
93 | swap(*this, other); | 93 | swap(*this, other); |
94 | } | 94 | } |
95 | 95 | ||
96 | filter& filter::operator=(filter other) | 96 | filter& filter::operator=(filter other) |
97 | { | 97 | { |
98 | swap(*this, other); | 98 | swap(*this, other); |
99 | 99 | ||
100 | return *this; | 100 | return *this; |
101 | } | 101 | } |
102 | 102 | ||
103 | void swap(filter& first, filter& second) | 103 | void swap(filter& first, filter& second) |
104 | { | 104 | { |
105 | using type = filter::type; | 105 | using type = filter::type; |
106 | using comparison = filter::comparison; | 106 | using comparison = filter::comparison; |
107 | 107 | ||
108 | type tempType = first.type_; | 108 | type tempType = first.type_; |
109 | field tempField; | 109 | field tempField; |
110 | comparison tempComparison; | 110 | comparison tempComparison; |
@@ -114,19 +114,19 @@ namespace verbly { | |||
114 | bool tempBoolValue; | 114 | bool tempBoolValue; |
115 | std::list<filter> tempChildren; | 115 | std::list<filter> tempChildren; |
116 | bool tempOrlogic; | 116 | bool tempOrlogic; |
117 | 117 | ||
118 | switch (tempType) | 118 | switch (tempType) |
119 | { | 119 | { |
120 | case type::empty: | 120 | case type::empty: |
121 | { | 121 | { |
122 | break; | 122 | break; |
123 | } | 123 | } |
124 | 124 | ||
125 | case type::singleton: | 125 | case type::singleton: |
126 | { | 126 | { |
127 | tempField = std::move(first.singleton_.filterField); | 127 | tempField = std::move(first.singleton_.filterField); |
128 | tempComparison = first.singleton_.filterType; | 128 | tempComparison = first.singleton_.filterType; |
129 | 129 | ||
130 | switch (tempComparison) | 130 | switch (tempComparison) |
131 | { | 131 | { |
132 | case comparison::int_equals: | 132 | case comparison::int_equals: |
@@ -137,72 +137,72 @@ namespace verbly { | |||
137 | case comparison::int_is_less_than: | 137 | case comparison::int_is_less_than: |
138 | { | 138 | { |
139 | tempIntValue = first.singleton_.intValue; | 139 | tempIntValue = first.singleton_.intValue; |
140 | 140 | ||
141 | break; | 141 | break; |
142 | } | 142 | } |
143 | 143 | ||
144 | case comparison::boolean_equals: | 144 | case comparison::boolean_equals: |
145 | { | 145 | { |
146 | tempBoolValue = first.singleton_.boolValue; | 146 | tempBoolValue = first.singleton_.boolValue; |
147 | 147 | ||
148 | break; | 148 | break; |
149 | } | 149 | } |
150 | 150 | ||
151 | case comparison::string_equals: | 151 | case comparison::string_equals: |
152 | case comparison::string_does_not_equal: | 152 | case comparison::string_does_not_equal: |
153 | case comparison::string_is_like: | 153 | case comparison::string_is_like: |
154 | case comparison::string_is_not_like: | 154 | case comparison::string_is_not_like: |
155 | { | 155 | { |
156 | tempStringValue = std::move(first.singleton_.stringValue); | 156 | tempStringValue = std::move(first.singleton_.stringValue); |
157 | 157 | ||
158 | break; | 158 | break; |
159 | } | 159 | } |
160 | 160 | ||
161 | case comparison::is_null: | 161 | case comparison::is_null: |
162 | case comparison::is_not_null: | 162 | case comparison::is_not_null: |
163 | { | 163 | { |
164 | break; | 164 | break; |
165 | } | 165 | } |
166 | 166 | ||
167 | case comparison::matches: | 167 | case comparison::matches: |
168 | case comparison::does_not_match: | 168 | case comparison::does_not_match: |
169 | case comparison::hierarchally_matches: | 169 | case comparison::hierarchally_matches: |
170 | case comparison::does_not_hierarchally_match: | 170 | case comparison::does_not_hierarchally_match: |
171 | { | 171 | { |
172 | tempJoin = std::move(first.singleton_.join); | 172 | tempJoin = std::move(first.singleton_.join); |
173 | 173 | ||
174 | break; | 174 | break; |
175 | } | 175 | } |
176 | } | 176 | } |
177 | 177 | ||
178 | break; | 178 | break; |
179 | } | 179 | } |
180 | 180 | ||
181 | case type::group: | 181 | case type::group: |
182 | { | 182 | { |
183 | tempChildren = std::move(first.group_.children); | 183 | tempChildren = std::move(first.group_.children); |
184 | tempOrlogic = first.group_.orlogic; | 184 | tempOrlogic = first.group_.orlogic; |
185 | 185 | ||
186 | break; | 186 | break; |
187 | } | 187 | } |
188 | } | 188 | } |
189 | 189 | ||
190 | first.~filter(); | 190 | first.~filter(); |
191 | 191 | ||
192 | first.type_ = second.type_; | 192 | first.type_ = second.type_; |
193 | 193 | ||
194 | switch (first.type_) | 194 | switch (first.type_) |
195 | { | 195 | { |
196 | case type::empty: | 196 | case type::empty: |
197 | { | 197 | { |
198 | break; | 198 | break; |
199 | } | 199 | } |
200 | 200 | ||
201 | case type::singleton: | 201 | case type::singleton: |
202 | { | 202 | { |
203 | new(&first.singleton_.filterField) field(std::move(second.singleton_.filterField)); | 203 | new(&first.singleton_.filterField) field(std::move(second.singleton_.filterField)); |
204 | first.singleton_.filterType = second.singleton_.filterType; | 204 | first.singleton_.filterType = second.singleton_.filterType; |
205 | 205 | ||
206 | switch (first.singleton_.filterType) | 206 | switch (first.singleton_.filterType) |
207 | { | 207 | { |
208 | case comparison::int_equals: | 208 | case comparison::int_equals: |
@@ -213,72 +213,72 @@ namespace verbly { | |||
213 | case comparison::int_is_less_than: | 213 | case comparison::int_is_less_than: |
214 | { | 214 | { |
215 | first.singleton_.intValue = second.singleton_.intValue; | 215 | first.singleton_.intValue = second.singleton_.intValue; |
216 | 216 | ||
217 | break; | 217 | break; |
218 | } | 218 | } |
219 | 219 | ||
220 | case comparison::boolean_equals: | 220 | case comparison::boolean_equals: |
221 | { | 221 | { |
222 | first.singleton_.boolValue = second.singleton_.boolValue; | 222 | first.singleton_.boolValue = second.singleton_.boolValue; |
223 | 223 | ||
224 | break; | 224 | break; |
225 | } | 225 | } |
226 | 226 | ||
227 | case comparison::string_equals: | 227 | case comparison::string_equals: |
228 | case comparison::string_does_not_equal: | 228 | case comparison::string_does_not_equal: |
229 | case comparison::string_is_like: | 229 | case comparison::string_is_like: |
230 | case comparison::string_is_not_like: | 230 | case comparison::string_is_not_like: |
231 | { | 231 | { |
232 | new(&first.singleton_.stringValue) std::string(std::move(second.singleton_.stringValue)); | 232 | new(&first.singleton_.stringValue) std::string(std::move(second.singleton_.stringValue)); |
233 | 233 | ||
234 | break; | 234 | break; |
235 | } | 235 | } |
236 | 236 | ||
237 | case comparison::is_null: | 237 | case comparison::is_null: |
238 | case comparison::is_not_null: | 238 | case comparison::is_not_null: |
239 | { | 239 | { |
240 | break; | 240 | break; |
241 | } | 241 | } |
242 | 242 | ||
243 | case comparison::matches: | 243 | case comparison::matches: |
244 | case comparison::does_not_match: | 244 | case comparison::does_not_match: |
245 | case comparison::hierarchally_matches: | 245 | case comparison::hierarchally_matches: |
246 | case comparison::does_not_hierarchally_match: | 246 | case comparison::does_not_hierarchally_match: |
247 | { | 247 | { |
248 | new(&first.singleton_.join) std::unique_ptr<filter>(std::move(second.singleton_.join)); | 248 | new(&first.singleton_.join) std::unique_ptr<filter>(std::move(second.singleton_.join)); |
249 | 249 | ||
250 | break; | 250 | break; |
251 | } | 251 | } |
252 | } | 252 | } |
253 | 253 | ||
254 | break; | 254 | break; |
255 | } | 255 | } |
256 | 256 | ||
257 | case type::group: | 257 | case type::group: |
258 | { | 258 | { |
259 | new(&first.group_.children) std::list<filter>(std::move(second.group_.children)); | 259 | new(&first.group_.children) std::list<filter>(std::move(second.group_.children)); |
260 | first.group_.orlogic = second.group_.orlogic; | 260 | first.group_.orlogic = second.group_.orlogic; |
261 | 261 | ||
262 | break; | 262 | break; |
263 | } | 263 | } |
264 | } | 264 | } |
265 | 265 | ||
266 | second.~filter(); | 266 | second.~filter(); |
267 | 267 | ||
268 | second.type_ = tempType; | 268 | second.type_ = tempType; |
269 | 269 | ||
270 | switch (second.type_) | 270 | switch (second.type_) |
271 | { | 271 | { |
272 | case type::empty: | 272 | case type::empty: |
273 | { | 273 | { |
274 | break; | 274 | break; |
275 | } | 275 | } |
276 | 276 | ||
277 | case type::singleton: | 277 | case type::singleton: |
278 | { | 278 | { |
279 | new(&second.singleton_.filterField) field(std::move(tempField)); | 279 | new(&second.singleton_.filterField) field(std::move(tempField)); |
280 | second.singleton_.filterType = tempComparison; | 280 | second.singleton_.filterType = tempComparison; |
281 | 281 | ||
282 | switch (second.singleton_.filterType) | 282 | switch (second.singleton_.filterType) |
283 | { | 283 | { |
284 | case comparison::int_equals: | 284 | case comparison::int_equals: |
@@ -289,57 +289,57 @@ namespace verbly { | |||
289 | case comparison::int_is_less_than: | 289 | case comparison::int_is_less_than: |
290 | { | 290 | { |
291 | second.singleton_.intValue = tempIntValue; | 291 | second.singleton_.intValue = tempIntValue; |
292 | 292 | ||
293 | break; | 293 | break; |
294 | } | 294 | } |
295 | 295 | ||
296 | case comparison::boolean_equals: | 296 | case comparison::boolean_equals: |
297 | { | 297 | { |
298 | second.singleton_.boolValue = tempBoolValue; | 298 | second.singleton_.boolValue = tempBoolValue; |
299 | 299 | ||
300 | break; | 300 | break; |
301 | } | 301 | } |
302 | 302 | ||
303 | case comparison::string_equals: | 303 | case comparison::string_equals: |
304 | case comparison::string_does_not_equal: | 304 | case comparison::string_does_not_equal: |
305 | case comparison::string_is_like: | 305 | case comparison::string_is_like: |
306 | case comparison::string_is_not_like: | 306 | case comparison::string_is_not_like: |
307 | { | 307 | { |
308 | new(&second.singleton_.stringValue) std::string(std::move(tempStringValue)); | 308 | new(&second.singleton_.stringValue) std::string(std::move(tempStringValue)); |
309 | 309 | ||
310 | break; | 310 | break; |
311 | } | 311 | } |
312 | 312 | ||
313 | case comparison::is_null: | 313 | case comparison::is_null: |
314 | case comparison::is_not_null: | 314 | case comparison::is_not_null: |
315 | { | 315 | { |
316 | break; | 316 | break; |
317 | } | 317 | } |
318 | 318 | ||
319 | case comparison::matches: | 319 | case comparison::matches: |
320 | case comparison::does_not_match: | 320 | case comparison::does_not_match: |
321 | case comparison::hierarchally_matches: | 321 | case comparison::hierarchally_matches: |
322 | case comparison::does_not_hierarchally_match: | 322 | case comparison::does_not_hierarchally_match: |
323 | { | 323 | { |
324 | new(&second.singleton_.join) std::unique_ptr<filter>(std::move(tempJoin)); | 324 | new(&second.singleton_.join) std::unique_ptr<filter>(std::move(tempJoin)); |
325 | 325 | ||
326 | break; | 326 | break; |
327 | } | 327 | } |
328 | } | 328 | } |
329 | 329 | ||
330 | break; | 330 | break; |
331 | } | 331 | } |
332 | 332 | ||
333 | case type::group: | 333 | case type::group: |
334 | { | 334 | { |
335 | new(&second.group_.children) std::list<filter>(std::move(tempChildren)); | 335 | new(&second.group_.children) std::list<filter>(std::move(tempChildren)); |
336 | second.group_.orlogic = tempOrlogic; | 336 | second.group_.orlogic = tempOrlogic; |
337 | 337 | ||
338 | break; | 338 | break; |
339 | } | 339 | } |
340 | } | 340 | } |
341 | } | 341 | } |
342 | 342 | ||
343 | filter::~filter() | 343 | filter::~filter() |
344 | { | 344 | { |
345 | switch (type_) | 345 | switch (type_) |
@@ -348,11 +348,11 @@ namespace verbly { | |||
348 | { | 348 | { |
349 | break; | 349 | break; |
350 | } | 350 | } |
351 | 351 | ||
352 | case type::singleton: | 352 | case type::singleton: |
353 | { | 353 | { |
354 | singleton_.filterField.~field(); | 354 | singleton_.filterField.~field(); |
355 | 355 | ||
356 | switch (singleton_.filterType) | 356 | switch (singleton_.filterType) |
357 | { | 357 | { |
358 | case comparison::int_equals: | 358 | case comparison::int_equals: |
@@ -367,50 +367,50 @@ namespace verbly { | |||
367 | { | 367 | { |
368 | break; | 368 | break; |
369 | } | 369 | } |
370 | 370 | ||
371 | case comparison::string_equals: | 371 | case comparison::string_equals: |
372 | case comparison::string_does_not_equal: | 372 | case comparison::string_does_not_equal: |
373 | case comparison::string_is_like: | 373 | case comparison::string_is_like: |
374 | case comparison::string_is_not_like: | 374 | case comparison::string_is_not_like: |
375 | { | 375 | { |
376 | using string_type = std::string; | 376 | using string_type = std::string; |
377 | 377 | ||
378 | singleton_.stringValue.~string_type(); | 378 | singleton_.stringValue.~string_type(); |
379 | 379 | ||
380 | break; | 380 | break; |
381 | } | 381 | } |
382 | 382 | ||
383 | case comparison::matches: | 383 | case comparison::matches: |
384 | case comparison::does_not_match: | 384 | case comparison::does_not_match: |
385 | case comparison::hierarchally_matches: | 385 | case comparison::hierarchally_matches: |
386 | case comparison::does_not_hierarchally_match: | 386 | case comparison::does_not_hierarchally_match: |
387 | { | 387 | { |
388 | using ptr_type = std::unique_ptr<filter>; | 388 | using ptr_type = std::unique_ptr<filter>; |
389 | 389 | ||
390 | singleton_.join.~ptr_type(); | 390 | singleton_.join.~ptr_type(); |
391 | 391 | ||
392 | break; | 392 | break; |
393 | } | 393 | } |
394 | } | 394 | } |
395 | 395 | ||
396 | break; | 396 | break; |
397 | } | 397 | } |
398 | 398 | ||
399 | case type::group: | 399 | case type::group: |
400 | { | 400 | { |
401 | using list_type = std::list<filter>; | 401 | using list_type = std::list<filter>; |
402 | 402 | ||
403 | group_.children.~list_type(); | 403 | group_.children.~list_type(); |
404 | 404 | ||
405 | break; | 405 | break; |
406 | } | 406 | } |
407 | } | 407 | } |
408 | } | 408 | } |
409 | 409 | ||
410 | filter::filter() | 410 | filter::filter() |
411 | { | 411 | { |
412 | } | 412 | } |
413 | 413 | ||
414 | filter::filter( | 414 | filter::filter( |
415 | field filterField, | 415 | field filterField, |
416 | comparison filterType, | 416 | comparison filterType, |
@@ -431,10 +431,10 @@ namespace verbly { | |||
431 | new(&singleton_.filterField) field(std::move(filterField)); | 431 | new(&singleton_.filterField) field(std::move(filterField)); |
432 | singleton_.filterType = filterType; | 432 | singleton_.filterType = filterType; |
433 | singleton_.intValue = filterValue; | 433 | singleton_.intValue = filterValue; |
434 | 434 | ||
435 | break; | 435 | break; |
436 | } | 436 | } |
437 | 437 | ||
438 | case comparison::boolean_equals: | 438 | case comparison::boolean_equals: |
439 | case comparison::string_equals: | 439 | case comparison::string_equals: |
440 | case comparison::string_does_not_equal: | 440 | case comparison::string_does_not_equal: |
@@ -454,7 +454,7 @@ namespace verbly { | |||
454 | throw std::domain_error("Cannot match a non-integer field against an integer value"); | 454 | throw std::domain_error("Cannot match a non-integer field against an integer value"); |
455 | } | 455 | } |
456 | } | 456 | } |
457 | 457 | ||
458 | filter::filter( | 458 | filter::filter( |
459 | field filterField, | 459 | field filterField, |
460 | comparison filterType, | 460 | comparison filterType, |
@@ -473,10 +473,10 @@ namespace verbly { | |||
473 | new(&singleton_.filterField) field(std::move(filterField)); | 473 | new(&singleton_.filterField) field(std::move(filterField)); |
474 | singleton_.filterType = filterType; | 474 | singleton_.filterType = filterType; |
475 | new(&singleton_.stringValue) std::string(std::move(filterValue)); | 475 | new(&singleton_.stringValue) std::string(std::move(filterValue)); |
476 | 476 | ||
477 | break; | 477 | break; |
478 | } | 478 | } |
479 | 479 | ||
480 | case comparison::int_equals: | 480 | case comparison::int_equals: |
481 | case comparison::int_does_not_equal: | 481 | case comparison::int_does_not_equal: |
482 | case comparison::int_is_at_least: | 482 | case comparison::int_is_at_least: |
@@ -498,7 +498,7 @@ namespace verbly { | |||
498 | throw std::domain_error("Cannot match a non-string field against an string value"); | 498 | throw std::domain_error("Cannot match a non-string field against an string value"); |
499 | } | 499 | } |
500 | } | 500 | } |
501 | 501 | ||
502 | filter::filter( | 502 | filter::filter( |
503 | field filterField, | 503 | field filterField, |
504 | comparison filterType, | 504 | comparison filterType, |
@@ -514,10 +514,10 @@ namespace verbly { | |||
514 | new(&singleton_.filterField) field(std::move(filterField)); | 514 | new(&singleton_.filterField) field(std::move(filterField)); |
515 | singleton_.filterType = filterType; | 515 | singleton_.filterType = filterType; |
516 | singleton_.boolValue = filterValue; | 516 | singleton_.boolValue = filterValue; |
517 | 517 | ||
518 | break; | 518 | break; |
519 | } | 519 | } |
520 | 520 | ||
521 | case comparison::string_equals: | 521 | case comparison::string_equals: |
522 | case comparison::string_does_not_equal: | 522 | case comparison::string_does_not_equal: |
523 | case comparison::string_is_like: | 523 | case comparison::string_is_like: |
@@ -542,7 +542,7 @@ namespace verbly { | |||
542 | throw std::domain_error("Cannot match a non-boolean field against a boolean value"); | 542 | throw std::domain_error("Cannot match a non-boolean field against a boolean value"); |
543 | } | 543 | } |
544 | } | 544 | } |
545 | 545 | ||
546 | filter::filter( | 546 | filter::filter( |
547 | field filterField, | 547 | field filterField, |
548 | comparison filterType) : | 548 | comparison filterType) : |
@@ -557,10 +557,10 @@ namespace verbly { | |||
557 | { | 557 | { |
558 | new(&singleton_.filterField) field(std::move(filterField)); | 558 | new(&singleton_.filterField) field(std::move(filterField)); |
559 | singleton_.filterType = filterType; | 559 | singleton_.filterType = filterType; |
560 | 560 | ||
561 | break; | 561 | break; |
562 | } | 562 | } |
563 | 563 | ||
564 | case comparison::string_equals: | 564 | case comparison::string_equals: |
565 | case comparison::string_does_not_equal: | 565 | case comparison::string_does_not_equal: |
566 | case comparison::string_is_like: | 566 | case comparison::string_is_like: |
@@ -584,7 +584,7 @@ namespace verbly { | |||
584 | throw std::domain_error("Cannot check nullity/non-nullity of non-nullable field"); | 584 | throw std::domain_error("Cannot check nullity/non-nullity of non-nullable field"); |
585 | } | 585 | } |
586 | } | 586 | } |
587 | 587 | ||
588 | filter::filter( | 588 | filter::filter( |
589 | field joinOn, | 589 | field joinOn, |
590 | comparison filterType, | 590 | comparison filterType, |
@@ -604,10 +604,10 @@ namespace verbly { | |||
604 | new(&singleton_.filterField) field(std::move(joinOn)); | 604 | new(&singleton_.filterField) field(std::move(joinOn)); |
605 | singleton_.filterType = filterType; | 605 | singleton_.filterType = filterType; |
606 | new(&singleton_.join) std::unique_ptr<filter>(new filter(joinCondition.normalize(singleton_.filterField.getJoinObject()))); | 606 | new(&singleton_.join) std::unique_ptr<filter>(new filter(joinCondition.normalize(singleton_.filterField.getJoinObject()))); |
607 | 607 | ||
608 | break; | 608 | break; |
609 | } | 609 | } |
610 | 610 | ||
611 | case comparison::int_equals: | 611 | case comparison::int_equals: |
612 | case comparison::int_does_not_equal: | 612 | case comparison::int_does_not_equal: |
613 | case comparison::int_is_at_least: | 613 | case comparison::int_is_at_least: |
@@ -627,10 +627,10 @@ namespace verbly { | |||
627 | throw std::invalid_argument("Incorrect constructor for given comparison"); | 627 | throw std::invalid_argument("Incorrect constructor for given comparison"); |
628 | } | 628 | } |
629 | } | 629 | } |
630 | 630 | ||
631 | break; | 631 | break; |
632 | } | 632 | } |
633 | 633 | ||
634 | case field::type::hierarchal_join: | 634 | case field::type::hierarchal_join: |
635 | { | 635 | { |
636 | switch (filterType) | 636 | switch (filterType) |
@@ -641,10 +641,10 @@ namespace verbly { | |||
641 | new(&singleton_.filterField) field(std::move(joinOn)); | 641 | new(&singleton_.filterField) field(std::move(joinOn)); |
642 | singleton_.filterType = filterType; | 642 | singleton_.filterType = filterType; |
643 | new(&singleton_.join) std::unique_ptr<filter>(new filter(joinCondition.normalize(singleton_.filterField.getObject()))); | 643 | new(&singleton_.join) std::unique_ptr<filter>(new filter(joinCondition.normalize(singleton_.filterField.getObject()))); |
644 | 644 | ||
645 | break; | 645 | break; |
646 | } | 646 | } |
647 | 647 | ||
648 | case comparison::int_equals: | 648 | case comparison::int_equals: |
649 | case comparison::int_does_not_equal: | 649 | case comparison::int_does_not_equal: |
650 | case comparison::int_is_at_least: | 650 | case comparison::int_is_at_least: |
@@ -664,10 +664,10 @@ namespace verbly { | |||
664 | throw std::invalid_argument("Incorrect constructor for given comparison"); | 664 | throw std::invalid_argument("Incorrect constructor for given comparison"); |
665 | } | 665 | } |
666 | } | 666 | } |
667 | 667 | ||
668 | break; | 668 | break; |
669 | } | 669 | } |
670 | 670 | ||
671 | case field::type::undefined: | 671 | case field::type::undefined: |
672 | case field::type::string: | 672 | case field::type::string: |
673 | case field::type::integer: | 673 | case field::type::integer: |
@@ -677,7 +677,7 @@ namespace verbly { | |||
677 | } | 677 | } |
678 | } | 678 | } |
679 | } | 679 | } |
680 | 680 | ||
681 | field filter::getField() const | 681 | field filter::getField() const |
682 | { | 682 | { |
683 | if (type_ == type::singleton) | 683 | if (type_ == type::singleton) |
@@ -687,7 +687,7 @@ namespace verbly { | |||
687 | throw std::domain_error("This filter does not have a field"); | 687 | throw std::domain_error("This filter does not have a field"); |
688 | } | 688 | } |
689 | } | 689 | } |
690 | 690 | ||
691 | filter::comparison filter::getComparison() const | 691 | filter::comparison filter::getComparison() const |
692 | { | 692 | { |
693 | if (type_ == type::singleton) | 693 | if (type_ == type::singleton) |
@@ -697,7 +697,7 @@ namespace verbly { | |||
697 | throw std::domain_error("This filter does not have a comparison"); | 697 | throw std::domain_error("This filter does not have a comparison"); |
698 | } | 698 | } |
699 | } | 699 | } |
700 | 700 | ||
701 | filter filter::getJoinCondition() const | 701 | filter filter::getJoinCondition() const |
702 | { | 702 | { |
703 | if (type_ == type::singleton) | 703 | if (type_ == type::singleton) |
@@ -711,7 +711,7 @@ namespace verbly { | |||
711 | { | 711 | { |
712 | return *singleton_.join; | 712 | return *singleton_.join; |
713 | } | 713 | } |
714 | 714 | ||
715 | case comparison::string_equals: | 715 | case comparison::string_equals: |
716 | case comparison::string_does_not_equal: | 716 | case comparison::string_does_not_equal: |
717 | case comparison::string_is_like: | 717 | case comparison::string_is_like: |
@@ -733,7 +733,7 @@ namespace verbly { | |||
733 | throw std::domain_error("This filter does not have a join condition"); | 733 | throw std::domain_error("This filter does not have a join condition"); |
734 | } | 734 | } |
735 | } | 735 | } |
736 | 736 | ||
737 | std::string filter::getStringArgument() const | 737 | std::string filter::getStringArgument() const |
738 | { | 738 | { |
739 | if (type_ == type::singleton) | 739 | if (type_ == type::singleton) |
@@ -747,7 +747,7 @@ namespace verbly { | |||
747 | { | 747 | { |
748 | return singleton_.stringValue; | 748 | return singleton_.stringValue; |
749 | } | 749 | } |
750 | 750 | ||
751 | case comparison::int_equals: | 751 | case comparison::int_equals: |
752 | case comparison::int_does_not_equal: | 752 | case comparison::int_does_not_equal: |
753 | case comparison::int_is_at_least: | 753 | case comparison::int_is_at_least: |
@@ -769,7 +769,7 @@ namespace verbly { | |||
769 | throw std::domain_error("This filter does not have a string argument"); | 769 | throw std::domain_error("This filter does not have a string argument"); |
770 | } | 770 | } |
771 | } | 771 | } |
772 | 772 | ||
773 | int filter::getIntegerArgument() const | 773 | int filter::getIntegerArgument() const |
774 | { | 774 | { |
775 | if (type_ == type::singleton) | 775 | if (type_ == type::singleton) |
@@ -785,7 +785,7 @@ namespace verbly { | |||
785 | { | 785 | { |
786 | return singleton_.intValue; | 786 | return singleton_.intValue; |
787 | } | 787 | } |
788 | 788 | ||
789 | case comparison::string_equals: | 789 | case comparison::string_equals: |
790 | case comparison::string_does_not_equal: | 790 | case comparison::string_does_not_equal: |
791 | case comparison::string_is_like: | 791 | case comparison::string_is_like: |
@@ -805,7 +805,7 @@ namespace verbly { | |||
805 | throw std::domain_error("This filter does not have an integer argument"); | 805 | throw std::domain_error("This filter does not have an integer argument"); |
806 | } | 806 | } |
807 | } | 807 | } |
808 | 808 | ||
809 | bool filter::getBooleanArgument() const | 809 | bool filter::getBooleanArgument() const |
810 | { | 810 | { |
811 | if ((type_ == type::singleton) && (singleton_.filterType == comparison::boolean_equals)) | 811 | if ((type_ == type::singleton) && (singleton_.filterType == comparison::boolean_equals)) |
@@ -815,13 +815,13 @@ namespace verbly { | |||
815 | throw std::domain_error("This filter does not have a boolean argument"); | 815 | throw std::domain_error("This filter does not have a boolean argument"); |
816 | } | 816 | } |
817 | } | 817 | } |
818 | 818 | ||
819 | filter::filter(bool orlogic) : type_(type::group) | 819 | filter::filter(bool orlogic) : type_(type::group) |
820 | { | 820 | { |
821 | new(&group_.children) std::list<filter>(); | 821 | new(&group_.children) std::list<filter>(); |
822 | group_.orlogic = orlogic; | 822 | group_.orlogic = orlogic; |
823 | } | 823 | } |
824 | 824 | ||
825 | bool filter::getOrlogic() const | 825 | bool filter::getOrlogic() const |
826 | { | 826 | { |
827 | if (type_ == type::group) | 827 | if (type_ == type::group) |
@@ -831,27 +831,27 @@ namespace verbly { | |||
831 | throw std::domain_error("This filter is not a group filter"); | 831 | throw std::domain_error("This filter is not a group filter"); |
832 | } | 832 | } |
833 | } | 833 | } |
834 | 834 | ||
835 | filter filter::operator+(filter condition) const | 835 | filter filter::operator+(filter condition) const |
836 | { | 836 | { |
837 | filter result(*this); | 837 | filter result(*this); |
838 | result += std::move(condition); | 838 | result += std::move(condition); |
839 | 839 | ||
840 | return result; | 840 | return result; |
841 | } | 841 | } |
842 | 842 | ||
843 | filter& filter::operator+=(filter condition) | 843 | filter& filter::operator+=(filter condition) |
844 | { | 844 | { |
845 | if (type_ == type::group) | 845 | if (type_ == type::group) |
846 | { | 846 | { |
847 | group_.children.push_back(std::move(condition)); | 847 | group_.children.push_back(std::move(condition)); |
848 | 848 | ||
849 | return *this; | 849 | return *this; |
850 | } else { | 850 | } else { |
851 | throw std::domain_error("Children can only be added to group filters"); | 851 | throw std::domain_error("Children can only be added to group filters"); |
852 | } | 852 | } |
853 | } | 853 | } |
854 | 854 | ||
855 | filter::const_iterator filter::begin() const | 855 | filter::const_iterator filter::begin() const |
856 | { | 856 | { |
857 | if (type_ == type::group) | 857 | if (type_ == type::group) |
@@ -861,7 +861,7 @@ namespace verbly { | |||
861 | throw std::domain_error("This filter has no children"); | 861 | throw std::domain_error("This filter has no children"); |
862 | } | 862 | } |
863 | } | 863 | } |
864 | 864 | ||
865 | filter::const_iterator filter::end() const | 865 | filter::const_iterator filter::end() const |
866 | { | 866 | { |
867 | if (type_ == type::group) | 867 | if (type_ == type::group) |
@@ -880,7 +880,7 @@ namespace verbly { | |||
880 | { | 880 | { |
881 | return {}; | 881 | return {}; |
882 | } | 882 | } |
883 | 883 | ||
884 | case type::singleton: | 884 | case type::singleton: |
885 | { | 885 | { |
886 | switch (singleton_.filterType) | 886 | switch (singleton_.filterType) |
@@ -889,113 +889,113 @@ namespace verbly { | |||
889 | { | 889 | { |
890 | return filter(singleton_.filterField, comparison::int_does_not_equal, singleton_.intValue); | 890 | return filter(singleton_.filterField, comparison::int_does_not_equal, singleton_.intValue); |
891 | } | 891 | } |
892 | 892 | ||
893 | case comparison::int_does_not_equal: | 893 | case comparison::int_does_not_equal: |
894 | { | 894 | { |
895 | return filter(singleton_.filterField, comparison::int_equals, singleton_.intValue); | 895 | return filter(singleton_.filterField, comparison::int_equals, singleton_.intValue); |
896 | } | 896 | } |
897 | 897 | ||
898 | case comparison::int_is_at_least: | 898 | case comparison::int_is_at_least: |
899 | { | 899 | { |
900 | return filter(singleton_.filterField, comparison::int_is_less_than, singleton_.intValue); | 900 | return filter(singleton_.filterField, comparison::int_is_less_than, singleton_.intValue); |
901 | } | 901 | } |
902 | 902 | ||
903 | case comparison::int_is_greater_than: | 903 | case comparison::int_is_greater_than: |
904 | { | 904 | { |
905 | return filter(singleton_.filterField, comparison::int_is_at_most, singleton_.intValue); | 905 | return filter(singleton_.filterField, comparison::int_is_at_most, singleton_.intValue); |
906 | } | 906 | } |
907 | 907 | ||
908 | case comparison::int_is_at_most: | 908 | case comparison::int_is_at_most: |
909 | { | 909 | { |
910 | return filter(singleton_.filterField, comparison::int_is_greater_than, singleton_.intValue); | 910 | return filter(singleton_.filterField, comparison::int_is_greater_than, singleton_.intValue); |
911 | } | 911 | } |
912 | 912 | ||
913 | case comparison::int_is_less_than: | 913 | case comparison::int_is_less_than: |
914 | { | 914 | { |
915 | return filter(singleton_.filterField, comparison::int_is_at_least, singleton_.intValue); | 915 | return filter(singleton_.filterField, comparison::int_is_at_least, singleton_.intValue); |
916 | } | 916 | } |
917 | 917 | ||
918 | case comparison::boolean_equals: | 918 | case comparison::boolean_equals: |
919 | { | 919 | { |
920 | return filter(singleton_.filterField, comparison::boolean_equals, !singleton_.boolValue); | 920 | return filter(singleton_.filterField, comparison::boolean_equals, !singleton_.boolValue); |
921 | } | 921 | } |
922 | 922 | ||
923 | case comparison::string_equals: | 923 | case comparison::string_equals: |
924 | { | 924 | { |
925 | return filter(singleton_.filterField, comparison::string_does_not_equal, singleton_.stringValue); | 925 | return filter(singleton_.filterField, comparison::string_does_not_equal, singleton_.stringValue); |
926 | } | 926 | } |
927 | 927 | ||
928 | case comparison::string_does_not_equal: | 928 | case comparison::string_does_not_equal: |
929 | { | 929 | { |
930 | return filter(singleton_.filterField, comparison::string_equals, singleton_.stringValue); | 930 | return filter(singleton_.filterField, comparison::string_equals, singleton_.stringValue); |
931 | } | 931 | } |
932 | 932 | ||
933 | case comparison::string_is_like: | 933 | case comparison::string_is_like: |
934 | { | 934 | { |
935 | return filter(singleton_.filterField, comparison::string_is_not_like, singleton_.stringValue); | 935 | return filter(singleton_.filterField, comparison::string_is_not_like, singleton_.stringValue); |
936 | } | 936 | } |
937 | 937 | ||
938 | case comparison::string_is_not_like: | 938 | case comparison::string_is_not_like: |
939 | { | 939 | { |
940 | return filter(singleton_.filterField, comparison::string_is_like, singleton_.stringValue); | 940 | return filter(singleton_.filterField, comparison::string_is_like, singleton_.stringValue); |
941 | } | 941 | } |
942 | 942 | ||
943 | case comparison::is_null: | 943 | case comparison::is_null: |
944 | { | 944 | { |
945 | return filter(singleton_.filterField, comparison::is_not_null); | 945 | return filter(singleton_.filterField, comparison::is_not_null); |
946 | } | 946 | } |
947 | 947 | ||
948 | case comparison::is_not_null: | 948 | case comparison::is_not_null: |
949 | { | 949 | { |
950 | return filter(singleton_.filterField, comparison::is_null); | 950 | return filter(singleton_.filterField, comparison::is_null); |
951 | } | 951 | } |
952 | 952 | ||
953 | case comparison::matches: | 953 | case comparison::matches: |
954 | { | 954 | { |
955 | return filter(singleton_.filterField, comparison::does_not_match, *singleton_.join); | 955 | return filter(singleton_.filterField, comparison::does_not_match, *singleton_.join); |
956 | } | 956 | } |
957 | 957 | ||
958 | case comparison::does_not_match: | 958 | case comparison::does_not_match: |
959 | { | 959 | { |
960 | return filter(singleton_.filterField, comparison::matches, *singleton_.join); | 960 | return filter(singleton_.filterField, comparison::matches, *singleton_.join); |
961 | } | 961 | } |
962 | 962 | ||
963 | case comparison::hierarchally_matches: | 963 | case comparison::hierarchally_matches: |
964 | { | 964 | { |
965 | return filter(singleton_.filterField, comparison::does_not_hierarchally_match, *singleton_.join); | 965 | return filter(singleton_.filterField, comparison::does_not_hierarchally_match, *singleton_.join); |
966 | } | 966 | } |
967 | 967 | ||
968 | case comparison::does_not_hierarchally_match: | 968 | case comparison::does_not_hierarchally_match: |
969 | { | 969 | { |
970 | return filter(singleton_.filterField, comparison::hierarchally_matches, *singleton_.join); | 970 | return filter(singleton_.filterField, comparison::hierarchally_matches, *singleton_.join); |
971 | } | 971 | } |
972 | } | 972 | } |
973 | } | 973 | } |
974 | 974 | ||
975 | case type::group: | 975 | case type::group: |
976 | { | 976 | { |
977 | filter result(!group_.orlogic); | 977 | filter result(!group_.orlogic); |
978 | 978 | ||
979 | for (const filter& child : group_.children) | 979 | for (const filter& child : group_.children) |
980 | { | 980 | { |
981 | result += !child; | 981 | result += !child; |
982 | } | 982 | } |
983 | 983 | ||
984 | return result; | 984 | return result; |
985 | } | 985 | } |
986 | } | 986 | } |
987 | } | 987 | } |
988 | 988 | ||
989 | filter& filter::operator&=(filter condition) | 989 | filter& filter::operator&=(filter condition) |
990 | { | 990 | { |
991 | return (*this = (*this && std::move(condition))); | 991 | return (*this = (*this && std::move(condition))); |
992 | } | 992 | } |
993 | 993 | ||
994 | filter& filter::operator|=(filter condition) | 994 | filter& filter::operator|=(filter condition) |
995 | { | 995 | { |
996 | return (*this = (*this || std::move(condition))); | 996 | return (*this = (*this || std::move(condition))); |
997 | } | 997 | } |
998 | 998 | ||
999 | filter filter::operator&&(filter condition) const | 999 | filter filter::operator&&(filter condition) const |
1000 | { | 1000 | { |
1001 | switch (type_) | 1001 | switch (type_) |
@@ -1004,16 +1004,16 @@ namespace verbly { | |||
1004 | { | 1004 | { |
1005 | return condition; | 1005 | return condition; |
1006 | } | 1006 | } |
1007 | 1007 | ||
1008 | case type::singleton: | 1008 | case type::singleton: |
1009 | { | 1009 | { |
1010 | filter result(false); | 1010 | filter result(false); |
1011 | result.group_.children.push_back(*this); | 1011 | result.group_.children.push_back(*this); |
1012 | result.group_.children.push_back(std::move(condition)); | 1012 | result.group_.children.push_back(std::move(condition)); |
1013 | 1013 | ||
1014 | return result; | 1014 | return result; |
1015 | } | 1015 | } |
1016 | 1016 | ||
1017 | case type::group: | 1017 | case type::group: |
1018 | { | 1018 | { |
1019 | if (group_.orlogic) | 1019 | if (group_.orlogic) |
@@ -1026,13 +1026,13 @@ namespace verbly { | |||
1026 | } else { | 1026 | } else { |
1027 | filter result(*this); | 1027 | filter result(*this); |
1028 | result.group_.children.push_back(std::move(condition)); | 1028 | result.group_.children.push_back(std::move(condition)); |
1029 | 1029 | ||
1030 | return result; | 1030 | return result; |
1031 | } | 1031 | } |
1032 | } | 1032 | } |
1033 | } | 1033 | } |
1034 | } | 1034 | } |
1035 | 1035 | ||
1036 | filter filter::operator||(filter condition) const | 1036 | filter filter::operator||(filter condition) const |
1037 | { | 1037 | { |
1038 | switch (type_) | 1038 | switch (type_) |
@@ -1041,16 +1041,16 @@ namespace verbly { | |||
1041 | { | 1041 | { |
1042 | return condition; | 1042 | return condition; |
1043 | } | 1043 | } |
1044 | 1044 | ||
1045 | case type::singleton: | 1045 | case type::singleton: |
1046 | { | 1046 | { |
1047 | filter result(true); | 1047 | filter result(true); |
1048 | result.group_.children.push_back(*this); | 1048 | result.group_.children.push_back(*this); |
1049 | result.group_.children.push_back(std::move(condition)); | 1049 | result.group_.children.push_back(std::move(condition)); |
1050 | 1050 | ||
1051 | return result; | 1051 | return result; |
1052 | } | 1052 | } |
1053 | 1053 | ||
1054 | case type::group: | 1054 | case type::group: |
1055 | { | 1055 | { |
1056 | if (!group_.orlogic) | 1056 | if (!group_.orlogic) |
@@ -1063,13 +1063,13 @@ namespace verbly { | |||
1063 | } else { | 1063 | } else { |
1064 | filter result(*this); | 1064 | filter result(*this); |
1065 | result.group_.children.push_back(std::move(condition)); | 1065 | result.group_.children.push_back(std::move(condition)); |
1066 | 1066 | ||
1067 | return result; | 1067 | return result; |
1068 | } | 1068 | } |
1069 | } | 1069 | } |
1070 | } | 1070 | } |
1071 | } | 1071 | } |
1072 | 1072 | ||
1073 | filter filter::normalize(object context) const | 1073 | filter filter::normalize(object context) const |
1074 | { | 1074 | { |
1075 | { | 1075 | { |
@@ -1096,7 +1096,7 @@ namespace verbly { | |||
1096 | // recontexualization. | 1096 | // recontexualization. |
1097 | return *this; | 1097 | return *this; |
1098 | } | 1098 | } |
1099 | 1099 | ||
1100 | case object::notion: | 1100 | case object::notion: |
1101 | { | 1101 | { |
1102 | switch (singleton_.filterField.getObject()) | 1102 | switch (singleton_.filterField.getObject()) |
@@ -1106,7 +1106,7 @@ namespace verbly { | |||
1106 | { | 1106 | { |
1107 | return *this; | 1107 | return *this; |
1108 | } | 1108 | } |
1109 | 1109 | ||
1110 | case object::word: | 1110 | case object::word: |
1111 | case object::group: | 1111 | case object::group: |
1112 | case object::frame: | 1112 | case object::frame: |
@@ -1118,7 +1118,7 @@ namespace verbly { | |||
1118 | } | 1118 | } |
1119 | } | 1119 | } |
1120 | } | 1120 | } |
1121 | 1121 | ||
1122 | case object::word: | 1122 | case object::word: |
1123 | { | 1123 | { |
1124 | switch (singleton_.filterField.getObject()) | 1124 | switch (singleton_.filterField.getObject()) |
@@ -1127,19 +1127,19 @@ namespace verbly { | |||
1127 | { | 1127 | { |
1128 | return (verbly::word::notion %= *this); | 1128 | return (verbly::word::notion %= *this); |
1129 | } | 1129 | } |
1130 | 1130 | ||
1131 | case object::undefined: | 1131 | case object::undefined: |
1132 | case object::word: | 1132 | case object::word: |
1133 | { | 1133 | { |
1134 | return *this; | 1134 | return *this; |
1135 | } | 1135 | } |
1136 | 1136 | ||
1137 | case object::group: | 1137 | case object::group: |
1138 | case object::frame: | 1138 | case object::frame: |
1139 | { | 1139 | { |
1140 | return (verbly::word::group %= *this); | 1140 | return (verbly::word::group %= *this); |
1141 | } | 1141 | } |
1142 | 1142 | ||
1143 | case object::lemma: | 1143 | case object::lemma: |
1144 | case object::form: | 1144 | case object::form: |
1145 | case object::pronunciation: | 1145 | case object::pronunciation: |
@@ -1147,7 +1147,7 @@ namespace verbly { | |||
1147 | return (verbly::word::lemma %= *this); | 1147 | return (verbly::word::lemma %= *this); |
1148 | } | 1148 | } |
1149 | } | 1149 | } |
1150 | 1150 | ||
1151 | case object::group: | 1151 | case object::group: |
1152 | { | 1152 | { |
1153 | switch (singleton_.filterField.getObject()) | 1153 | switch (singleton_.filterField.getObject()) |
@@ -1157,7 +1157,7 @@ namespace verbly { | |||
1157 | { | 1157 | { |
1158 | return *this; | 1158 | return *this; |
1159 | } | 1159 | } |
1160 | 1160 | ||
1161 | case object::notion: | 1161 | case object::notion: |
1162 | case object::word: | 1162 | case object::word: |
1163 | case object::lemma: | 1163 | case object::lemma: |
@@ -1166,14 +1166,14 @@ namespace verbly { | |||
1166 | { | 1166 | { |
1167 | return (verbly::group::word %= *this); | 1167 | return (verbly::group::word %= *this); |
1168 | } | 1168 | } |
1169 | 1169 | ||
1170 | case object::frame: | 1170 | case object::frame: |
1171 | { | 1171 | { |
1172 | return (verbly::group::frame %= *this); | 1172 | return (verbly::group::frame %= *this); |
1173 | } | 1173 | } |
1174 | } | 1174 | } |
1175 | } | 1175 | } |
1176 | 1176 | ||
1177 | case object::frame: | 1177 | case object::frame: |
1178 | { | 1178 | { |
1179 | switch (singleton_.filterField.getObject()) | 1179 | switch (singleton_.filterField.getObject()) |
@@ -1183,7 +1183,7 @@ namespace verbly { | |||
1183 | { | 1183 | { |
1184 | return *this; | 1184 | return *this; |
1185 | } | 1185 | } |
1186 | 1186 | ||
1187 | case object::notion: | 1187 | case object::notion: |
1188 | case object::word: | 1188 | case object::word: |
1189 | case object::group: | 1189 | case object::group: |
@@ -1195,7 +1195,7 @@ namespace verbly { | |||
1195 | } | 1195 | } |
1196 | } | 1196 | } |
1197 | } | 1197 | } |
1198 | 1198 | ||
1199 | case object::lemma: | 1199 | case object::lemma: |
1200 | { | 1200 | { |
1201 | switch (singleton_.filterField.getObject()) | 1201 | switch (singleton_.filterField.getObject()) |
@@ -1207,7 +1207,7 @@ namespace verbly { | |||
1207 | { | 1207 | { |
1208 | return verbly::lemma::word %= *this; | 1208 | return verbly::lemma::word %= *this; |
1209 | } | 1209 | } |
1210 | 1210 | ||
1211 | case object::undefined: | 1211 | case object::undefined: |
1212 | case object::lemma: | 1212 | case object::lemma: |
1213 | { | 1213 | { |
@@ -1221,7 +1221,7 @@ namespace verbly { | |||
1221 | } | 1221 | } |
1222 | } | 1222 | } |
1223 | } | 1223 | } |
1224 | 1224 | ||
1225 | case object::form: | 1225 | case object::form: |
1226 | { | 1226 | { |
1227 | switch (singleton_.filterField.getObject()) | 1227 | switch (singleton_.filterField.getObject()) |
@@ -1234,7 +1234,7 @@ namespace verbly { | |||
1234 | { | 1234 | { |
1235 | return verbly::form::lemma(inflection::base) %= *this; | 1235 | return verbly::form::lemma(inflection::base) %= *this; |
1236 | } | 1236 | } |
1237 | 1237 | ||
1238 | case object::undefined: | 1238 | case object::undefined: |
1239 | case object::form: | 1239 | case object::form: |
1240 | { | 1240 | { |
@@ -1247,7 +1247,7 @@ namespace verbly { | |||
1247 | } | 1247 | } |
1248 | } | 1248 | } |
1249 | } | 1249 | } |
1250 | 1250 | ||
1251 | case object::pronunciation: | 1251 | case object::pronunciation: |
1252 | { | 1252 | { |
1253 | switch (singleton_.filterField.getObject()) | 1253 | switch (singleton_.filterField.getObject()) |
@@ -1261,7 +1261,7 @@ namespace verbly { | |||
1261 | { | 1261 | { |
1262 | return verbly::pronunciation::form %= *this; | 1262 | return verbly::pronunciation::form %= *this; |
1263 | } | 1263 | } |
1264 | 1264 | ||
1265 | case object::undefined: | 1265 | case object::undefined: |
1266 | case object::pronunciation: | 1266 | case object::pronunciation: |
1267 | { | 1267 | { |
@@ -1276,7 +1276,8 @@ namespace verbly { | |||
1276 | case type::group: | 1276 | case type::group: |
1277 | { | 1277 | { |
1278 | filter result(group_.orlogic); | 1278 | filter result(group_.orlogic); |
1279 | std::map<field, filter> joins; | 1279 | std::map<field, filter> positiveJoins; |
1280 | std::map<field, filter> negativeJoins; | ||
1280 | 1281 | ||
1281 | for (const filter& child : group_.children) | 1282 | for (const filter& child : group_.children) |
1282 | { | 1283 | { |
@@ -1291,28 +1292,28 @@ namespace verbly { | |||
1291 | { | 1292 | { |
1292 | case comparison::matches: | 1293 | case comparison::matches: |
1293 | { | 1294 | { |
1294 | if (!joins.count(normalized.singleton_.filterField)) | 1295 | if (!positiveJoins.count(normalized.singleton_.filterField)) |
1295 | { | 1296 | { |
1296 | joins[normalized.getField()] = filter(group_.orlogic); | 1297 | positiveJoins[normalized.getField()] = filter(group_.orlogic); |
1297 | } | 1298 | } |
1298 | 1299 | ||
1299 | joins.at(normalized.getField()) += std::move(*normalized.singleton_.join); | 1300 | positiveJoins.at(normalized.getField()) += std::move(*normalized.singleton_.join); |
1300 | 1301 | ||
1301 | break; | 1302 | break; |
1302 | } | 1303 | } |
1303 | 1304 | ||
1304 | case comparison::does_not_match: | 1305 | case comparison::does_not_match: |
1305 | { | 1306 | { |
1306 | if (!joins.count(normalized.singleton_.filterField)) | 1307 | if (!negativeJoins.count(normalized.singleton_.filterField)) |
1307 | { | 1308 | { |
1308 | joins[normalized.getField()] = filter(group_.orlogic); | 1309 | negativeJoins[normalized.getField()] = filter(group_.orlogic); |
1309 | } | 1310 | } |
1310 | 1311 | ||
1311 | joins.at(normalized.getField()) += !*normalized.singleton_.join; | 1312 | negativeJoins.at(normalized.getField()) += std::move(*normalized.singleton_.join); |
1312 | 1313 | ||
1313 | break; | 1314 | break; |
1314 | } | 1315 | } |
1315 | 1316 | ||
1316 | case comparison::int_equals: | 1317 | case comparison::int_equals: |
1317 | case comparison::int_does_not_equal: | 1318 | case comparison::int_does_not_equal: |
1318 | case comparison::int_is_at_least: | 1319 | case comparison::int_is_at_least: |
@@ -1330,25 +1331,25 @@ namespace verbly { | |||
1330 | case comparison::does_not_hierarchally_match: | 1331 | case comparison::does_not_hierarchally_match: |
1331 | { | 1332 | { |
1332 | result += std::move(normalized); | 1333 | result += std::move(normalized); |
1333 | 1334 | ||
1334 | break; | 1335 | break; |
1335 | } | 1336 | } |
1336 | } | 1337 | } |
1337 | 1338 | ||
1338 | break; | 1339 | break; |
1339 | } | 1340 | } |
1340 | 1341 | ||
1341 | case type::group: | 1342 | case type::group: |
1342 | case type::empty: | 1343 | case type::empty: |
1343 | { | 1344 | { |
1344 | result += std::move(normalized); | 1345 | result += std::move(normalized); |
1345 | 1346 | ||
1346 | break; | 1347 | break; |
1347 | } | 1348 | } |
1348 | } | 1349 | } |
1349 | } | 1350 | } |
1350 | 1351 | ||
1351 | for (auto& mapping : joins) | 1352 | for (auto& mapping : positiveJoins) |
1352 | { | 1353 | { |
1353 | const field& joinOn = mapping.first; | 1354 | const field& joinOn = mapping.first; |
1354 | filter& joinCondition = mapping.second; | 1355 | filter& joinCondition = mapping.second; |
@@ -1356,6 +1357,14 @@ namespace verbly { | |||
1356 | result += (joinOn %= joinCondition.normalize(joinOn.getJoinObject())); | 1357 | result += (joinOn %= joinCondition.normalize(joinOn.getJoinObject())); |
1357 | } | 1358 | } |
1358 | 1359 | ||
1360 | for (auto& mapping : negativeJoins) | ||
1361 | { | ||
1362 | const field& joinOn = mapping.first; | ||
1363 | filter& joinCondition = mapping.second; | ||
1364 | |||
1365 | result += !(joinOn %= joinCondition.normalize(joinOn.getJoinObject())); | ||
1366 | } | ||
1367 | |||
1359 | return result; | 1368 | return result; |
1360 | } | 1369 | } |
1361 | } | 1370 | } |