LCOV - code coverage report
Current view: top level - lib/src - operations.g.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 38 177 21.5 %
Date: 2020-04-21 18:42:01 Functions: 0 0 -

          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             : }

Generated by: LCOV version 1.14