LCOV - code coverage report
Current view: top level - lib/src/image - filter.g.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 16 72 22.2 %
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 'filter.dart';
       4             : 
       5             : // **************************************************************************
       6             : // SuperEnumGenerator
       7             : // **************************************************************************
       8             : 
       9             : @immutable
      10             : abstract class Filter extends Equatable {
      11           0 :   const Filter(this._type);
      12             : 
      13             :   factory Filter.nearest() = Nearest;
      14             : 
      15             :   factory Filter.bilinear() = Bilinear;
      16             : 
      17             :   factory Filter.bicubic() = Bicubic;
      18             : 
      19             :   factory Filter.lanczos() = Lanczos;
      20             : 
      21             :   final _Filter _type;
      22             : 
      23             : //ignore: missing_return
      24           1 :   R when<R>(
      25             :       {@required R Function(Nearest) nearest,
      26             :       @required R Function(Bilinear) bilinear,
      27             :       @required R Function(Bicubic) bicubic,
      28             :       @required R Function(Lanczos) lanczos}) {
      29           1 :     assert(() {
      30             :       if (nearest == null ||
      31             :           bilinear == null ||
      32             :           bicubic == null ||
      33             :           lanczos == null) {
      34             :         throw 'check for all possible cases';
      35             :       }
      36             :       return true;
      37           1 :     }());
      38           1 :     switch (this._type) {
      39           1 :       case _Filter.Nearest:
      40           1 :         return nearest(this as Nearest);
      41           1 :       case _Filter.Bilinear:
      42           1 :         return bilinear(this as Bilinear);
      43           1 :       case _Filter.Bicubic:
      44           1 :         return bicubic(this as Bicubic);
      45           1 :       case _Filter.Lanczos:
      46           1 :         return lanczos(this as Lanczos);
      47             :     }
      48             :   }
      49             : 
      50             : //ignore: missing_return
      51           0 :   Future<R> asyncWhen<R>(
      52             :       {@required FutureOr<R> Function(Nearest) nearest,
      53             :       @required FutureOr<R> Function(Bilinear) bilinear,
      54             :       @required FutureOr<R> Function(Bicubic) bicubic,
      55             :       @required FutureOr<R> Function(Lanczos) lanczos}) {
      56           0 :     assert(() {
      57             :       if (nearest == null ||
      58             :           bilinear == null ||
      59             :           bicubic == null ||
      60             :           lanczos == null) {
      61             :         throw 'check for all possible cases';
      62             :       }
      63             :       return true;
      64           0 :     }());
      65           0 :     switch (this._type) {
      66           0 :       case _Filter.Nearest:
      67           0 :         return nearest(this as Nearest);
      68           0 :       case _Filter.Bilinear:
      69           0 :         return bilinear(this as Bilinear);
      70           0 :       case _Filter.Bicubic:
      71           0 :         return bicubic(this as Bicubic);
      72           0 :       case _Filter.Lanczos:
      73           0 :         return lanczos(this as Lanczos);
      74             :     }
      75             :   }
      76             : 
      77           0 :   R whenOrElse<R>(
      78             :       {R Function(Nearest) nearest,
      79             :       R Function(Bilinear) bilinear,
      80             :       R Function(Bicubic) bicubic,
      81             :       R Function(Lanczos) lanczos,
      82             :       @required R Function(Filter) orElse}) {
      83           0 :     assert(() {
      84             :       if (orElse == null) {
      85             :         throw 'Missing orElse case';
      86             :       }
      87             :       return true;
      88           0 :     }());
      89           0 :     switch (this._type) {
      90           0 :       case _Filter.Nearest:
      91             :         if (nearest == null) break;
      92           0 :         return nearest(this as Nearest);
      93           0 :       case _Filter.Bilinear:
      94             :         if (bilinear == null) break;
      95           0 :         return bilinear(this as Bilinear);
      96           0 :       case _Filter.Bicubic:
      97             :         if (bicubic == null) break;
      98           0 :         return bicubic(this as Bicubic);
      99           0 :       case _Filter.Lanczos:
     100             :         if (lanczos == null) break;
     101           0 :         return lanczos(this as Lanczos);
     102             :     }
     103           0 :     return orElse(this);
     104             :   }
     105             : 
     106           0 :   Future<R> asyncWhenOrElse<R>(
     107             :       {FutureOr<R> Function(Nearest) nearest,
     108             :       FutureOr<R> Function(Bilinear) bilinear,
     109             :       FutureOr<R> Function(Bicubic) bicubic,
     110             :       FutureOr<R> Function(Lanczos) lanczos,
     111             :       @required FutureOr<R> Function(Filter) orElse}) {
     112           0 :     assert(() {
     113             :       if (orElse == null) {
     114             :         throw 'Missing orElse case';
     115             :       }
     116             :       return true;
     117           0 :     }());
     118           0 :     switch (this._type) {
     119           0 :       case _Filter.Nearest:
     120             :         if (nearest == null) break;
     121           0 :         return nearest(this as Nearest);
     122           0 :       case _Filter.Bilinear:
     123             :         if (bilinear == null) break;
     124           0 :         return bilinear(this as Bilinear);
     125           0 :       case _Filter.Bicubic:
     126             :         if (bicubic == null) break;
     127           0 :         return bicubic(this as Bicubic);
     128           0 :       case _Filter.Lanczos:
     129             :         if (lanczos == null) break;
     130           0 :         return lanczos(this as Lanczos);
     131             :     }
     132           0 :     return orElse(this);
     133             :   }
     134             : 
     135             : //ignore: missing_return
     136           0 :   Future<void> whenPartial(
     137             :       {FutureOr<void> Function(Nearest) nearest,
     138             :       FutureOr<void> Function(Bilinear) bilinear,
     139             :       FutureOr<void> Function(Bicubic) bicubic,
     140             :       FutureOr<void> Function(Lanczos) lanczos}) {
     141           0 :     assert(() {
     142             :       if (nearest == null &&
     143             :           bilinear == null &&
     144             :           bicubic == null &&
     145             :           lanczos == null) {
     146             :         throw 'provide at least one branch';
     147             :       }
     148             :       return true;
     149           0 :     }());
     150           0 :     switch (this._type) {
     151           0 :       case _Filter.Nearest:
     152             :         if (nearest == null) break;
     153           0 :         return nearest(this as Nearest);
     154           0 :       case _Filter.Bilinear:
     155             :         if (bilinear == null) break;
     156           0 :         return bilinear(this as Bilinear);
     157           0 :       case _Filter.Bicubic:
     158             :         if (bicubic == null) break;
     159           0 :         return bicubic(this as Bicubic);
     160           0 :       case _Filter.Lanczos:
     161             :         if (lanczos == null) break;
     162           0 :         return lanczos(this as Lanczos);
     163             :     }
     164             :   }
     165             : 
     166           0 :   @override
     167             :   List get props => const [];
     168             : }
     169             : 
     170             : @immutable
     171             : class Nearest extends Filter {
     172           0 :   const Nearest._() : super(_Filter.Nearest);
     173             : 
     174           1 :   factory Nearest() {
     175             :     _instance ??= const Nearest._();
     176             :     return _instance;
     177             :   }
     178             : 
     179             :   static Nearest _instance;
     180             : }
     181             : 
     182             : @immutable
     183             : class Bilinear extends Filter {
     184           0 :   const Bilinear._() : super(_Filter.Bilinear);
     185             : 
     186           1 :   factory Bilinear() {
     187             :     _instance ??= const Bilinear._();
     188             :     return _instance;
     189             :   }
     190             : 
     191             :   static Bilinear _instance;
     192             : }
     193             : 
     194             : @immutable
     195             : class Bicubic extends Filter {
     196           0 :   const Bicubic._() : super(_Filter.Bicubic);
     197             : 
     198           1 :   factory Bicubic() {
     199             :     _instance ??= const Bicubic._();
     200             :     return _instance;
     201             :   }
     202             : 
     203             :   static Bicubic _instance;
     204             : }
     205             : 
     206             : @immutable
     207             : class Lanczos extends Filter {
     208           0 :   const Lanczos._() : super(_Filter.Lanczos);
     209             : 
     210           1 :   factory Lanczos() {
     211             :     _instance ??= const Lanczos._();
     212             :     return _instance;
     213             :   }
     214             : 
     215             :   static Lanczos _instance;
     216             : }

Generated by: LCOV version 1.15