// Filled during heal.
	HealedBuckets []string

	// ID of the current healing operation
	HealID string

	ItemsSkipped uint64
	BytesSkipped uint64

	RetryAttempts uint64

	Finished bool // finished healing, whether with errors or not

	// Add future tracking capabilities
	// Be sure that they are included in toHealingDisk
}

// loadHealingTracker will load the healing tracker from the supplied disk.

    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;
      }
      crc0 = combine(0, crc0);
      crc0 = combine(crc0, crc1);
      crc0 = combine(crc0, crc2);
      crc0 = combine(crc0, crc3);
      while (bb.hasRemaining()) {
        crc0 = (crc0 >>> 8) ^ byteTable[(bb.get() ^ crc0) & 0xFF];
      }
      finished = true;
    }

    @Override

            }
            forceStop();
        }
    }

    /**
     * Adds a finished session ID to the cleanup list.
     * This method is thread-safe and adds the session ID to be cleaned up later.
     *
     * @param sessionId the crawler session ID that has finished processing
     */
    public void addFinishedSessionId(final String sessionId) {
        synchronized (finishedSessionIdList) {

		lastHandout:  metaCacheTestsetTimestamp,
		dataVersion:  metacacheStreamVersion,
	},
	8: {
		id:           "case-8-finished-a-week-ago",
		bucket:       "bucket",
		root:         "folder/finished",
		recursive:    false,
		status:       scanStateSuccess,
		fileNotFound: false,
		error:        "",
		started:      metaCacheTestsetTimestamp.Add(-7 * 24 * time.Hour),

    assertThat(stopwatch.elapsed(MILLISECONDS)).isIn(Range.closed(NOT_ENOUGH_MS, DELAY_MS * 2));
    // Is it still computing away anyway?
    assertThat(target.finished).isFalse();
    MILLISECONDS.sleep(ENOUGH_MS);
    assertThat(target.finished).isFalse();
  }

  public void testNewProxy_badMethodWithEnoughTime() throws Exception {
    SampleImpl target = new SampleImpl(DELAY_MS);

                if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                    logger.info("Finished job: id={}", id);
                }
            } else {
                if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                    logger.info("Finished job: id={}, returnValue:\n{}", id, ret);
                }
                jobLog.setScriptResult(ret.toString());
            }

	dataVersion  uint8      `msg:"v"`
}

func (m *metacache) finished() bool {
	return !m.ended.IsZero()
}

// worthKeeping indicates if the cache by itself is worth keeping.
func (m *metacache) worthKeeping() bool {
	if m == nil {
		return false
	}
	cache := m
	switch {
	case !cache.finished() && time.Since(cache.lastUpdate) > metacacheMaxRunningAge:
		// Not finished and update for metacacheMaxRunningAge, discard it.
		return false

import org.jspecify.annotations.NullUnmarked;

/** Measures the size of AbstractFuture implementations. */
@NullUnmarked
public class AbstractFutureFootprintBenchmark {

  enum State {
    NOT_DONE,
    FINISHED,
    CANCELLED,
    FAILED
  }

  @Param State state;
  @Param Impl impl;

  @Param({"0", "1", "5", "10"})
  int numListeners;

  @Param({"0", "1", "5", "10"})
  int numThreads;

:: the License.

@echo off

set configure_dir=%~dp0
set configure_dir=%configure_dir:~0,-1%
python "%configure_dir%\configure.py" %* || ( exit /b )

		case "RetryAttempts":
			z.RetryAttempts, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "RetryAttempts")
				return
			}
		case "Finished":
			z.Finished, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Finished")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}