| 1 |  |  | import 'dart:async'; | 
                
                
                    | 2 |  |  |  | 
                
                
                    | 3 |  |  | import '../exceptions/squadron_exception.dart'; | 
                
                
                    | 4 |  |  | import '../stats/perf_counter.dart'; | 
                
                
                    | 5 |  |  | import '../worker/worker.dart'; | 
                
                
                    | 6 |  |  | import '_worker_task.dart'; | 
                
                
                    | 7 |  |  | import 'value_task.dart'; | 
                
                
                    | 8 |  |  |  | 
                
                
                    | 9 |  |  | final class WorkerValueTask<T, W extends Worker> extends WorkerTask<T, W> | 
                
                
                    | 10 |  |  |     implements ValueTask<T> { | 
                
                
                    | 11 |  |  |   /// Creates a new [ValueTask]. | 
                
                
                    | 12 |  | 8 |   WorkerValueTask(this._computer, PerfCounter? counter) : super(counter); | 
                
                
                    | 13 |  |  |  | 
                
                
                    | 14 |  |  |   final Future<T> Function(W worker) _computer; | 
                
                
                    | 15 |  |  |   final _result = Completer<T>(); | 
                
                
                    | 16 |  |  |   final _done = Completer<void>(); | 
                
                
                    | 17 |  |  |  | 
                
                
                    | 18 |  | 0 |   @override | 
                
                
                    | 19 |  | 0 |   Future<void> get done => _done.future; | 
                
                
                    | 20 |  |  |  | 
                
                
                    | 21 |  | 4 |   @override | 
                
                
                    | 22 |  | 8 |   Future<T> get value => _result.future; | 
                
                
                    | 23 |  |  |  | 
                
                
                    | 24 |  | 2 |   void _failure(SquadronException exception) { | 
                
                
                    | 25 |  | 4 |     if (!_result.isCompleted) { | 
                
                
                    | 26 |  | 4 |       _result.completeError(exception); | 
                
                
                    | 27 |  |  |     } | 
                
                
                    | 28 |  |  |   } | 
                
                
                    | 29 |  |  |  | 
                
                
                    | 30 |  | 4 |   void _success(dynamic data) { | 
                
                
                    | 31 |  | 8 |     if (!_result.isCompleted) { | 
                
                
                    | 32 |  | 8 |       _result.complete(data); | 
                
                
                    | 33 |  |  |     } | 
                
                
                    | 34 |  |  |   } | 
                
                
                    | 35 |  |  |  | 
                
                
                    | 36 |  | 2 |   @override | 
                
                
                    | 37 |  |  |   void cancel([String? message]) { | 
                
                
                    | 38 |  | 2 |     super.cancel(message); | 
                
                
                    | 39 |  | 4 |     _failure(canceledException!); | 
                
                
                    | 40 |  |  |   } | 
                
                
                    | 41 |  |  |  | 
                
                
                    | 42 |  | 4 |   @override | 
                
                
                    | 43 |  |  |   Future<bool> execute(W worker) async { | 
                
                
                    | 44 |  |  |     try { | 
                
                
                    | 45 |  | 4 |       throwIfCanceled(); | 
                
                
                    | 46 |  | 8 |       final res = await _computer(worker); | 
                
                
                    | 47 |  | 4 |       _success(res); | 
                
                
                    | 48 |  |  |       return true; | 
                
                
                    | 49 |  |  |     } catch (ex, st) { | 
                
                
                    | 50 |  | 2 |       _failure(SquadronException.from(ex, st)); | 
                
                
                    | 51 |  |  |       return false; | 
                
                
                    | 52 |  |  |     } | 
                
                
                    | 53 |  |  |   } | 
                
                
                    | 54 |  |  | } |