Line data Source code
1 : // GENERATED CODE - DO NOT MODIFY BY HAND
2 :
3 : part of 'operations.dart';
4 :
5 : // **************************************************************************
6 : // SuperEnumGenerator
7 : // **************************************************************************
8 :
9 : @immutable
10 : abstract class QueryOperation extends Equatable {
11 1 : const QueryOperation(this._type);
12 :
13 : factory QueryOperation.equals({@required dynamic value}) = Equals;
14 :
15 : factory QueryOperation.notEquals({@required dynamic value}) = NotEquals;
16 :
17 : factory QueryOperation.includes({@required List<dynamic> value}) = Includes;
18 :
19 : factory QueryOperation.excludes({@required List<dynamic> value}) = Excludes;
20 :
21 : factory QueryOperation.isLessThan({@required dynamic value}) = IsLessThan;
22 :
23 : factory QueryOperation.isLessThanOrEqual({@required dynamic value}) =
24 : IsLessThanOrEqual;
25 :
26 : factory QueryOperation.isGreaterThan({@required dynamic value}) =
27 : IsGreaterThan;
28 :
29 : factory QueryOperation.isGreaterThanOrEqual({@required dynamic value}) =
30 : IsGreaterThanOrEqual;
31 :
32 : factory QueryOperation.exists({@required bool value}) = Exists;
33 :
34 : factory QueryOperation.matches({@required String regex}) = Matches;
35 :
36 : final _QueryOperation _type;
37 :
38 : //ignore: missing_return
39 1 : R when<R>(
40 : {@required R Function(Equals) equals,
41 : @required R Function(NotEquals) notEquals,
42 : @required R Function(Includes) includes,
43 : @required R Function(Excludes) excludes,
44 : @required R Function(IsLessThan) isLessThan,
45 : @required R Function(IsLessThanOrEqual) isLessThanOrEqual,
46 : @required R Function(IsGreaterThan) isGreaterThan,
47 : @required R Function(IsGreaterThanOrEqual) isGreaterThanOrEqual,
48 : @required R Function(Exists) exists,
49 : @required R Function(Matches) matches}) {
50 1 : assert(() {
51 : if (equals == null ||
52 : notEquals == null ||
53 : includes == null ||
54 : excludes == null ||
55 : isLessThan == null ||
56 : isLessThanOrEqual == null ||
57 : isGreaterThan == null ||
58 : isGreaterThanOrEqual == null ||
59 : exists == null ||
60 : matches == null) {
61 : throw 'check for all possible cases';
62 : }
63 : return true;
64 1 : }());
65 1 : switch (this._type) {
66 1 : case _QueryOperation.Equals:
67 1 : return equals(this as Equals);
68 1 : case _QueryOperation.NotEquals:
69 1 : return notEquals(this as NotEquals);
70 1 : case _QueryOperation.Includes:
71 1 : return includes(this as Includes);
72 1 : case _QueryOperation.Excludes:
73 1 : return excludes(this as Excludes);
74 1 : case _QueryOperation.IsLessThan:
75 1 : return isLessThan(this as IsLessThan);
76 1 : case _QueryOperation.IsLessThanOrEqual:
77 1 : return isLessThanOrEqual(this as IsLessThanOrEqual);
78 1 : case _QueryOperation.IsGreaterThan:
79 1 : return isGreaterThan(this as IsGreaterThan);
80 1 : case _QueryOperation.IsGreaterThanOrEqual:
81 1 : return isGreaterThanOrEqual(this as IsGreaterThanOrEqual);
82 1 : case _QueryOperation.Exists:
83 1 : return exists(this as Exists);
84 1 : case _QueryOperation.Matches:
85 1 : return matches(this as Matches);
86 : }
87 : }
88 :
89 : //ignore: missing_return
90 0 : Future<R> asyncWhen<R>(
91 : {@required FutureOr<R> Function(Equals) equals,
92 : @required FutureOr<R> Function(NotEquals) notEquals,
93 : @required FutureOr<R> Function(Includes) includes,
94 : @required FutureOr<R> Function(Excludes) excludes,
95 : @required FutureOr<R> Function(IsLessThan) isLessThan,
96 : @required FutureOr<R> Function(IsLessThanOrEqual) isLessThanOrEqual,
97 : @required FutureOr<R> Function(IsGreaterThan) isGreaterThan,
98 : @required FutureOr<R> Function(IsGreaterThanOrEqual) isGreaterThanOrEqual,
99 : @required FutureOr<R> Function(Exists) exists,
100 : @required FutureOr<R> Function(Matches) matches}) {
101 0 : assert(() {
102 : if (equals == null ||
103 : notEquals == null ||
104 : includes == null ||
105 : excludes == null ||
106 : isLessThan == null ||
107 : isLessThanOrEqual == null ||
108 : isGreaterThan == null ||
109 : isGreaterThanOrEqual == null ||
110 : exists == null ||
111 : matches == null) {
112 : throw 'check for all possible cases';
113 : }
114 : return true;
115 0 : }());
116 0 : switch (this._type) {
117 0 : case _QueryOperation.Equals:
118 0 : return equals(this as Equals);
119 0 : case _QueryOperation.NotEquals:
120 0 : return notEquals(this as NotEquals);
121 0 : case _QueryOperation.Includes:
122 0 : return includes(this as Includes);
123 0 : case _QueryOperation.Excludes:
124 0 : return excludes(this as Excludes);
125 0 : case _QueryOperation.IsLessThan:
126 0 : return isLessThan(this as IsLessThan);
127 0 : case _QueryOperation.IsLessThanOrEqual:
128 0 : return isLessThanOrEqual(this as IsLessThanOrEqual);
129 0 : case _QueryOperation.IsGreaterThan:
130 0 : return isGreaterThan(this as IsGreaterThan);
131 0 : case _QueryOperation.IsGreaterThanOrEqual:
132 0 : return isGreaterThanOrEqual(this as IsGreaterThanOrEqual);
133 0 : case _QueryOperation.Exists:
134 0 : return exists(this as Exists);
135 0 : case _QueryOperation.Matches:
136 0 : return matches(this as Matches);
137 : }
138 : }
139 :
140 0 : R whenOrElse<R>(
141 : {R Function(Equals) equals,
142 : R Function(NotEquals) notEquals,
143 : R Function(Includes) includes,
144 : R Function(Excludes) excludes,
145 : R Function(IsLessThan) isLessThan,
146 : R Function(IsLessThanOrEqual) isLessThanOrEqual,
147 : R Function(IsGreaterThan) isGreaterThan,
148 : R Function(IsGreaterThanOrEqual) isGreaterThanOrEqual,
149 : R Function(Exists) exists,
150 : R Function(Matches) matches,
151 : @required R Function(QueryOperation) orElse}) {
152 0 : assert(() {
153 : if (orElse == null) {
154 : throw 'Missing orElse case';
155 : }
156 : return true;
157 0 : }());
158 0 : switch (this._type) {
159 0 : case _QueryOperation.Equals:
160 : if (equals == null) break;
161 0 : return equals(this as Equals);
162 0 : case _QueryOperation.NotEquals:
163 : if (notEquals == null) break;
164 0 : return notEquals(this as NotEquals);
165 0 : case _QueryOperation.Includes:
166 : if (includes == null) break;
167 0 : return includes(this as Includes);
168 0 : case _QueryOperation.Excludes:
169 : if (excludes == null) break;
170 0 : return excludes(this as Excludes);
171 0 : case _QueryOperation.IsLessThan:
172 : if (isLessThan == null) break;
173 0 : return isLessThan(this as IsLessThan);
174 0 : case _QueryOperation.IsLessThanOrEqual:
175 : if (isLessThanOrEqual == null) break;
176 0 : return isLessThanOrEqual(this as IsLessThanOrEqual);
177 0 : case _QueryOperation.IsGreaterThan:
178 : if (isGreaterThan == null) break;
179 0 : return isGreaterThan(this as IsGreaterThan);
180 0 : case _QueryOperation.IsGreaterThanOrEqual:
181 : if (isGreaterThanOrEqual == null) break;
182 0 : return isGreaterThanOrEqual(this as IsGreaterThanOrEqual);
183 0 : case _QueryOperation.Exists:
184 : if (exists == null) break;
185 0 : return exists(this as Exists);
186 0 : case _QueryOperation.Matches:
187 : if (matches == null) break;
188 0 : return matches(this as Matches);
189 : }
190 0 : return orElse(this);
191 : }
192 :
193 0 : Future<R> asyncWhenOrElse<R>(
194 : {FutureOr<R> Function(Equals) equals,
195 : FutureOr<R> Function(NotEquals) notEquals,
196 : FutureOr<R> Function(Includes) includes,
197 : FutureOr<R> Function(Excludes) excludes,
198 : FutureOr<R> Function(IsLessThan) isLessThan,
199 : FutureOr<R> Function(IsLessThanOrEqual) isLessThanOrEqual,
200 : FutureOr<R> Function(IsGreaterThan) isGreaterThan,
201 : FutureOr<R> Function(IsGreaterThanOrEqual) isGreaterThanOrEqual,
202 : FutureOr<R> Function(Exists) exists,
203 : FutureOr<R> Function(Matches) matches,
204 : @required FutureOr<R> Function(QueryOperation) orElse}) {
205 0 : assert(() {
206 : if (orElse == null) {
207 : throw 'Missing orElse case';
208 : }
209 : return true;
210 0 : }());
211 0 : switch (this._type) {
212 0 : case _QueryOperation.Equals:
213 : if (equals == null) break;
214 0 : return equals(this as Equals);
215 0 : case _QueryOperation.NotEquals:
216 : if (notEquals == null) break;
217 0 : return notEquals(this as NotEquals);
218 0 : case _QueryOperation.Includes:
219 : if (includes == null) break;
220 0 : return includes(this as Includes);
221 0 : case _QueryOperation.Excludes:
222 : if (excludes == null) break;
223 0 : return excludes(this as Excludes);
224 0 : case _QueryOperation.IsLessThan:
225 : if (isLessThan == null) break;
226 0 : return isLessThan(this as IsLessThan);
227 0 : case _QueryOperation.IsLessThanOrEqual:
228 : if (isLessThanOrEqual == null) break;
229 0 : return isLessThanOrEqual(this as IsLessThanOrEqual);
230 0 : case _QueryOperation.IsGreaterThan:
231 : if (isGreaterThan == null) break;
232 0 : return isGreaterThan(this as IsGreaterThan);
233 0 : case _QueryOperation.IsGreaterThanOrEqual:
234 : if (isGreaterThanOrEqual == null) break;
235 0 : return isGreaterThanOrEqual(this as IsGreaterThanOrEqual);
236 0 : case _QueryOperation.Exists:
237 : if (exists == null) break;
238 0 : return exists(this as Exists);
239 0 : case _QueryOperation.Matches:
240 : if (matches == null) break;
241 0 : return matches(this as Matches);
242 : }
243 0 : return orElse(this);
244 : }
245 :
246 : //ignore: missing_return
247 0 : Future<void> whenPartial(
248 : {FutureOr<void> Function(Equals) equals,
249 : FutureOr<void> Function(NotEquals) notEquals,
250 : FutureOr<void> Function(Includes) includes,
251 : FutureOr<void> Function(Excludes) excludes,
252 : FutureOr<void> Function(IsLessThan) isLessThan,
253 : FutureOr<void> Function(IsLessThanOrEqual) isLessThanOrEqual,
254 : FutureOr<void> Function(IsGreaterThan) isGreaterThan,
255 : FutureOr<void> Function(IsGreaterThanOrEqual) isGreaterThanOrEqual,
256 : FutureOr<void> Function(Exists) exists,
257 : FutureOr<void> Function(Matches) matches}) {
258 0 : assert(() {
259 : if (equals == null &&
260 : notEquals == null &&
261 : includes == null &&
262 : excludes == null &&
263 : isLessThan == null &&
264 : isLessThanOrEqual == null &&
265 : isGreaterThan == null &&
266 : isGreaterThanOrEqual == null &&
267 : exists == null &&
268 : matches == null) {
269 : throw 'provide at least one branch';
270 : }
271 : return true;
272 0 : }());
273 0 : switch (this._type) {
274 0 : case _QueryOperation.Equals:
275 : if (equals == null) break;
276 0 : return equals(this as Equals);
277 0 : case _QueryOperation.NotEquals:
278 : if (notEquals == null) break;
279 0 : return notEquals(this as NotEquals);
280 0 : case _QueryOperation.Includes:
281 : if (includes == null) break;
282 0 : return includes(this as Includes);
283 0 : case _QueryOperation.Excludes:
284 : if (excludes == null) break;
285 0 : return excludes(this as Excludes);
286 0 : case _QueryOperation.IsLessThan:
287 : if (isLessThan == null) break;
288 0 : return isLessThan(this as IsLessThan);
289 0 : case _QueryOperation.IsLessThanOrEqual:
290 : if (isLessThanOrEqual == null) break;
291 0 : return isLessThanOrEqual(this as IsLessThanOrEqual);
292 0 : case _QueryOperation.IsGreaterThan:
293 : if (isGreaterThan == null) break;
294 0 : return isGreaterThan(this as IsGreaterThan);
295 0 : case _QueryOperation.IsGreaterThanOrEqual:
296 : if (isGreaterThanOrEqual == null) break;
297 0 : return isGreaterThanOrEqual(this as IsGreaterThanOrEqual);
298 0 : case _QueryOperation.Exists:
299 : if (exists == null) break;
300 0 : return exists(this as Exists);
301 0 : case _QueryOperation.Matches:
302 : if (matches == null) break;
303 0 : return matches(this as Matches);
304 : }
305 : }
306 :
307 0 : @override
308 : List get props => const [];
309 : }
310 :
311 : @immutable
312 : class Equals extends QueryOperation {
313 2 : const Equals({@required this.value}) : super(_QueryOperation.Equals);
314 :
315 : final dynamic value;
316 :
317 0 : @override
318 0 : String toString() => 'Equals(value:${this.value})';
319 0 : @override
320 0 : List get props => [value];
321 : }
322 :
323 : @immutable
324 : class NotEquals extends QueryOperation {
325 2 : const NotEquals({@required this.value}) : super(_QueryOperation.NotEquals);
326 :
327 : final dynamic value;
328 :
329 0 : @override
330 0 : String toString() => 'NotEquals(value:${this.value})';
331 0 : @override
332 0 : List get props => [value];
333 : }
334 :
335 : @immutable
336 : class Includes extends QueryOperation {
337 2 : const Includes({@required this.value}) : super(_QueryOperation.Includes);
338 :
339 : final List<dynamic> value;
340 :
341 0 : @override
342 0 : String toString() => 'Includes(value:${this.value})';
343 0 : @override
344 0 : List get props => [value];
345 : }
346 :
347 : @immutable
348 : class Excludes extends QueryOperation {
349 2 : const Excludes({@required this.value}) : super(_QueryOperation.Excludes);
350 :
351 : final List<dynamic> value;
352 :
353 0 : @override
354 0 : String toString() => 'Excludes(value:${this.value})';
355 0 : @override
356 0 : List get props => [value];
357 : }
358 :
359 : @immutable
360 : class IsLessThan extends QueryOperation {
361 2 : const IsLessThan({@required this.value}) : super(_QueryOperation.IsLessThan);
362 :
363 : final dynamic value;
364 :
365 0 : @override
366 0 : String toString() => 'IsLessThan(value:${this.value})';
367 0 : @override
368 0 : List get props => [value];
369 : }
370 :
371 : @immutable
372 : class IsLessThanOrEqual extends QueryOperation {
373 1 : const IsLessThanOrEqual({@required this.value})
374 1 : : super(_QueryOperation.IsLessThanOrEqual);
375 :
376 : final dynamic value;
377 :
378 0 : @override
379 0 : String toString() => 'IsLessThanOrEqual(value:${this.value})';
380 0 : @override
381 0 : List get props => [value];
382 : }
383 :
384 : @immutable
385 : class IsGreaterThan extends QueryOperation {
386 1 : const IsGreaterThan({@required this.value})
387 1 : : super(_QueryOperation.IsGreaterThan);
388 :
389 : final dynamic value;
390 :
391 0 : @override
392 0 : String toString() => 'IsGreaterThan(value:${this.value})';
393 0 : @override
394 0 : List get props => [value];
395 : }
396 :
397 : @immutable
398 : class IsGreaterThanOrEqual extends QueryOperation {
399 1 : const IsGreaterThanOrEqual({@required this.value})
400 1 : : super(_QueryOperation.IsGreaterThanOrEqual);
401 :
402 : final dynamic value;
403 :
404 0 : @override
405 0 : String toString() => 'IsGreaterThanOrEqual(value:${this.value})';
406 0 : @override
407 0 : List get props => [value];
408 : }
409 :
410 : @immutable
411 : class Exists extends QueryOperation {
412 2 : const Exists({@required this.value}) : super(_QueryOperation.Exists);
413 :
414 : final bool value;
415 :
416 0 : @override
417 0 : String toString() => 'Exists(value:${this.value})';
418 0 : @override
419 0 : List get props => [value];
420 : }
421 :
422 : @immutable
423 : class Matches extends QueryOperation {
424 2 : const Matches({@required this.regex}) : super(_QueryOperation.Matches);
425 :
426 : final String regex;
427 :
428 0 : @override
429 0 : String toString() => 'Matches(regex:${this.regex})';
430 0 : @override
431 0 : List get props => [regex];
432 : }
|