LCOV - code coverage report
Current view: top level - lib/src - reference.g.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 11 54 20.4 %
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 'reference.dart';
       4             : 
       5             : // **************************************************************************
       6             : // SuperEnumGenerator
       7             : // **************************************************************************
       8             : 
       9             : @immutable
      10             : abstract class QueryReference extends Equatable {
      11           1 :   const QueryReference(this._type);
      12             : 
      13             :   factory QueryReference.include({@required Query query}) = Include;
      14             : 
      15             :   factory QueryReference.notInclude({@required Query query}) = NotInclude;
      16             : 
      17             :   final _QueryReference _type;
      18             : 
      19             : //ignore: missing_return
      20           1 :   R when<R>(
      21             :       {@required R Function(Include) include,
      22             :       @required R Function(NotInclude) notInclude}) {
      23           1 :     assert(() {
      24             :       if (include == null || notInclude == null) {
      25             :         throw 'check for all possible cases';
      26             :       }
      27             :       return true;
      28           1 :     }());
      29           1 :     switch (this._type) {
      30           1 :       case _QueryReference.Include:
      31           1 :         return include(this as Include);
      32           1 :       case _QueryReference.NotInclude:
      33           1 :         return notInclude(this as NotInclude);
      34             :     }
      35             :   }
      36             : 
      37             : //ignore: missing_return
      38           0 :   Future<R> asyncWhen<R>(
      39             :       {@required FutureOr<R> Function(Include) include,
      40             :       @required FutureOr<R> Function(NotInclude) notInclude}) {
      41           0 :     assert(() {
      42             :       if (include == null || notInclude == null) {
      43             :         throw 'check for all possible cases';
      44             :       }
      45             :       return true;
      46           0 :     }());
      47           0 :     switch (this._type) {
      48           0 :       case _QueryReference.Include:
      49           0 :         return include(this as Include);
      50           0 :       case _QueryReference.NotInclude:
      51           0 :         return notInclude(this as NotInclude);
      52             :     }
      53             :   }
      54             : 
      55           0 :   R whenOrElse<R>(
      56             :       {R Function(Include) include,
      57             :       R Function(NotInclude) notInclude,
      58             :       @required R Function(QueryReference) orElse}) {
      59           0 :     assert(() {
      60             :       if (orElse == null) {
      61             :         throw 'Missing orElse case';
      62             :       }
      63             :       return true;
      64           0 :     }());
      65           0 :     switch (this._type) {
      66           0 :       case _QueryReference.Include:
      67             :         if (include == null) break;
      68           0 :         return include(this as Include);
      69           0 :       case _QueryReference.NotInclude:
      70             :         if (notInclude == null) break;
      71           0 :         return notInclude(this as NotInclude);
      72             :     }
      73           0 :     return orElse(this);
      74             :   }
      75             : 
      76           0 :   Future<R> asyncWhenOrElse<R>(
      77             :       {FutureOr<R> Function(Include) include,
      78             :       FutureOr<R> Function(NotInclude) notInclude,
      79             :       @required FutureOr<R> Function(QueryReference) orElse}) {
      80           0 :     assert(() {
      81             :       if (orElse == null) {
      82             :         throw 'Missing orElse case';
      83             :       }
      84             :       return true;
      85           0 :     }());
      86           0 :     switch (this._type) {
      87           0 :       case _QueryReference.Include:
      88             :         if (include == null) break;
      89           0 :         return include(this as Include);
      90           0 :       case _QueryReference.NotInclude:
      91             :         if (notInclude == null) break;
      92           0 :         return notInclude(this as NotInclude);
      93             :     }
      94           0 :     return orElse(this);
      95             :   }
      96             : 
      97             : //ignore: missing_return
      98           0 :   Future<void> whenPartial(
      99             :       {FutureOr<void> Function(Include) include,
     100             :       FutureOr<void> Function(NotInclude) notInclude}) {
     101           0 :     assert(() {
     102             :       if (include == null && notInclude == null) {
     103             :         throw 'provide at least one branch';
     104             :       }
     105             :       return true;
     106           0 :     }());
     107           0 :     switch (this._type) {
     108           0 :       case _QueryReference.Include:
     109             :         if (include == null) break;
     110           0 :         return include(this as Include);
     111           0 :       case _QueryReference.NotInclude:
     112             :         if (notInclude == null) break;
     113           0 :         return notInclude(this as NotInclude);
     114             :     }
     115             :   }
     116             : 
     117           0 :   @override
     118             :   List get props => const [];
     119             : }
     120             : 
     121             : @immutable
     122             : class Include extends QueryReference {
     123           2 :   const Include({@required this.query}) : super(_QueryReference.Include);
     124             : 
     125             :   final Query query;
     126             : 
     127           0 :   @override
     128           0 :   String toString() => 'Include(query:${this.query})';
     129           0 :   @override
     130           0 :   List get props => [query];
     131             : }
     132             : 
     133             : @immutable
     134             : class NotInclude extends QueryReference {
     135           2 :   const NotInclude({@required this.query}) : super(_QueryReference.NotInclude);
     136             : 
     137             :   final Query query;
     138             : 
     139           0 :   @override
     140           0 :   String toString() => 'NotInclude(query:${this.query})';
     141           0 :   @override
     142           0 :   List get props => [query];
     143             : }

Generated by: LCOV version 1.14