execute method

Future<bool> execute(Future<void> callback())

Returns true if this call was executed (not dropped/queued).

Implementation

Future<bool> execute(Future<void> Function() callback) async {
  if (!enabled) {
    _debugLog('AsyncExecutor bypassed (disabled)');
    final startTime = DateTime.now();
    await callback();
    onMetrics?.call(DateTime.now().difference(startTime));
    return true;
  }

  final callId = ++_currentCallId;

  switch (mode) {
    case ConcurrencyMode.drop:
      if (_isExecuting) {
        _debugLog('Dropped (already executing)');
        return false;
      }
      break;

    case ConcurrencyMode.replace:
      if (_isExecuting) {
        _debugLog('Replacing current execution');
      }
      // New call takes over - old one will check callId and bail
      break;

    case ConcurrencyMode.keepLatest:
      if (_isExecuting) {
        _queuedCallback = callback;
        _debugLog('Queued as latest (will replace previous)');
        return false;
      }
      break;

    case ConcurrencyMode.enqueue:
      if (_isExecuting) {
        _queue.add(callback);
        _debugLog('Enqueued (queue size: ${_queue.length})');
        return false;
      }
      break;
  }

  _activeCallId = callId;
  _isExecuting = true;
  _debugLog('Executing (mode: ${mode.name})');

  final startTime = DateTime.now();
  try {
    if (maxDuration != null) {
      await callback().timeout(maxDuration!);
    } else {
      await callback();
    }
    final executionTime = DateTime.now().difference(startTime);
    _debugLog('Completed in ${executionTime.inMilliseconds}ms');
    onMetrics?.call(executionTime);
    // Return true only if this call wasn't superseded
    return _currentCallId == callId;
  } catch (e) {
    _debugLog('Error: $e');
    if (resetOnError) {
      reset();
    }
    rethrow;
  } finally {
    if (_activeCallId == callId) {
      _isExecuting = false;
      _activeCallId = null;

      // Execute queued callback for keepLatest mode
      if (mode == ConcurrencyMode.keepLatest && _queuedCallback != null) {
        final queued = _queuedCallback;
        _queuedCallback = null;
        _debugLog('Processing kept latest callback');
        await execute(queued!);
      }

      // Process queue for enqueue mode
      if (mode == ConcurrencyMode.enqueue && _queue.isNotEmpty) {
        _processQueue();
      }
    }
  }
}