retry<T> function

Future<T> retry<T>(FutureOr<T> computation(), { Cancelable? cancelable, Future<void> cancel()?, Able? able, })

retry Retry operation. computation Computation operation. cancelable Cancelable context. cancel Cancel function called when cancelable.cancel(). able Able to retry

Implementation

Future<T> retry<T>(FutureOr<T> Function() computation,
    {Cancelable? cancelable,
    Future<void> Function()? cancel,
    Able? able}) async {
  bool cancelled = false;
  final disposable = cancelable?.whenCancel(() {
    if (cancelled == true) {
      return;
    }
    cancelled = true;
    if (cancel == null) {
      return;
    }
    cancel();
  });
  int i = 0;
  while (true) {
    try {
      var t = await computation();
      disposable?.dispose();
      return t;
    } catch (e) {
      try {
        if (cancelled == true) {
          rethrow;
        }
        if (able == null) {
          rethrow;
        }
        await able(++i, e);
        if (cancelled == true) {
          rethrow;
        }
      } catch (e) {
        disposable?.dispose();
        rethrow;
      }
    }
  }
}