LCOV - code coverage report
Current view: top level - lib/src/enums - operator.g.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 11 54 20.4 %
Date: 2020-10-22 14:54:13 Functions: 0 0 -

          Line data    Source code
       1             : // GENERATED CODE - DO NOT MODIFY BY HAND
       2             : 
       3             : part of 'operator.dart';
       4             : 
       5             : // **************************************************************************
       6             : // SuperEnumGenerator
       7             : // **************************************************************************
       8             : 
       9             : @immutable
      10             : abstract class QueryOperator extends Equatable {
      11           1 :   const QueryOperator(this._type);
      12             : 
      13             :   factory QueryOperator.and({@required List<Query> queryObjects}) = And;
      14             : 
      15             :   factory QueryOperator.or({@required List<Query> queryObjects}) = Or;
      16             : 
      17             :   final _QueryOperator _type;
      18             : 
      19             : //ignore: missing_return
      20           1 :   R when<R>({@required R Function(And) and, @required R Function(Or) or}) {
      21           1 :     assert(() {
      22             :       if (and == null || or == null) {
      23             :         throw 'check for all possible cases';
      24             :       }
      25             :       return true;
      26           1 :     }());
      27           1 :     switch (this._type) {
      28           1 :       case _QueryOperator.And:
      29           1 :         return and(this as And);
      30           1 :       case _QueryOperator.Or:
      31           1 :         return or(this as Or);
      32             :     }
      33             :   }
      34             : 
      35             : //ignore: missing_return
      36           0 :   Future<R> asyncWhen<R>(
      37             :       {@required FutureOr<R> Function(And) and,
      38             :       @required FutureOr<R> Function(Or) or}) {
      39           0 :     assert(() {
      40             :       if (and == null || or == null) {
      41             :         throw 'check for all possible cases';
      42             :       }
      43             :       return true;
      44           0 :     }());
      45           0 :     switch (this._type) {
      46           0 :       case _QueryOperator.And:
      47           0 :         return and(this as And);
      48           0 :       case _QueryOperator.Or:
      49           0 :         return or(this as Or);
      50             :     }
      51             :   }
      52             : 
      53           0 :   R whenOrElse<R>(
      54             :       {R Function(And) and,
      55             :       R Function(Or) or,
      56             :       @required R Function(QueryOperator) orElse}) {
      57           0 :     assert(() {
      58             :       if (orElse == null) {
      59             :         throw 'Missing orElse case';
      60             :       }
      61             :       return true;
      62           0 :     }());
      63           0 :     switch (this._type) {
      64           0 :       case _QueryOperator.And:
      65             :         if (and == null) break;
      66           0 :         return and(this as And);
      67           0 :       case _QueryOperator.Or:
      68             :         if (or == null) break;
      69           0 :         return or(this as Or);
      70             :     }
      71           0 :     return orElse(this);
      72             :   }
      73             : 
      74           0 :   Future<R> asyncWhenOrElse<R>(
      75             :       {FutureOr<R> Function(And) and,
      76             :       FutureOr<R> Function(Or) or,
      77             :       @required FutureOr<R> Function(QueryOperator) orElse}) {
      78           0 :     assert(() {
      79             :       if (orElse == null) {
      80             :         throw 'Missing orElse case';
      81             :       }
      82             :       return true;
      83           0 :     }());
      84           0 :     switch (this._type) {
      85           0 :       case _QueryOperator.And:
      86             :         if (and == null) break;
      87           0 :         return and(this as And);
      88           0 :       case _QueryOperator.Or:
      89             :         if (or == null) break;
      90           0 :         return or(this as Or);
      91             :     }
      92           0 :     return orElse(this);
      93             :   }
      94             : 
      95             : //ignore: missing_return
      96           0 :   Future<void> whenPartial(
      97             :       {FutureOr<void> Function(And) and, FutureOr<void> Function(Or) or}) {
      98           0 :     assert(() {
      99             :       if (and == null && or == null) {
     100             :         throw 'provide at least one branch';
     101             :       }
     102             :       return true;
     103           0 :     }());
     104           0 :     switch (this._type) {
     105           0 :       case _QueryOperator.And:
     106             :         if (and == null) break;
     107           0 :         return and(this as And);
     108           0 :       case _QueryOperator.Or:
     109             :         if (or == null) break;
     110           0 :         return or(this as Or);
     111             :     }
     112             :   }
     113             : 
     114           0 :   @override
     115             :   List get props => const [];
     116             : }
     117             : 
     118             : @immutable
     119             : class And extends QueryOperator {
     120           2 :   const And({@required this.queryObjects}) : super(_QueryOperator.And);
     121             : 
     122             :   final List<Query> queryObjects;
     123             : 
     124           0 :   @override
     125           0 :   String toString() => 'And(queryObjects:${this.queryObjects})';
     126           0 :   @override
     127           0 :   List get props => [queryObjects];
     128             : }
     129             : 
     130             : @immutable
     131             : class Or extends QueryOperator {
     132           2 :   const Or({@required this.queryObjects}) : super(_QueryOperator.Or);
     133             : 
     134             :   final List<Query> queryObjects;
     135             : 
     136           0 :   @override
     137           0 :   String toString() => 'Or(queryObjects:${this.queryObjects})';
     138           0 :   @override
     139           0 :   List get props => [queryObjects];
     140             : }

Generated by: LCOV version 1.15