type Config struct {
	ReplicationWorkersWait time.Duration `json:"replicationWorkersWait"`
	KeyRotationWorkersWait time.Duration `json:"keyRotationWorkersWait"`
	ExpirationWorkersWait  time.Duration `json:"expirationWorkersWait"`
}

// ExpirationWait returns the duration for which a batch expiration worker
// would wait before working on next object.
func (opts Config) ExpirationWait() time.Duration {
	configMu.RLock()
	defer configMu.RUnlock()

import java.math.BigDecimal;

public class Duration {
    public static final Units<Duration> MILLI_SECONDS = Units.base(Duration.class, "ms");
    public static final Units<Duration> SECONDS = MILLI_SECONDS.times(1000, "s");
    public static final Units<Duration> MINUTES = SECONDS.times(60, "m");
    public static final Units<Duration> HOURS = MINUTES.times(60, "h");

    public static Amount<Duration> millis(long millis) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.test.fixtures.concurrent

class Duration {
    private final long nanos

    Duration(long nanos) {
        this.nanos = nanos
    }

    long getMillis() {
        return nanos / 1000000
    }

    @Override
    String toString() {

John Howard <******@****.***> 1709052916 -0800

    }

    def "can convert between units"() {
        expect:
        Duration.millis(45000) == Duration.seconds(45)
        Duration.seconds(0.98) == Duration.millis(980)
        Duration.seconds(120) == Duration.minutes(2)
        Duration.seconds(30) == Duration.minutes(0.5)
        Duration.hours(30) == Duration.millis(30 * 60 * 60 * 1000)
    }

  }

  static class DurationSpec {
    private final long duration;
    private final TimeUnit unit;

    private DurationSpec(long duration, TimeUnit unit) {
      this.duration = duration;
      this.unit = unit;
    }

    public static DurationSpec of(long duration, TimeUnit unit) {
      return new DurationSpec(duration, unit);
    }

    @Override
    public int hashCode() {

}

// record adds the given duration to the distribution.
//
// Disallow preemptions and stack growths because this function
// may run in sensitive locations.
//
//go:nosplit
func (h *timeHistogram) record(duration int64) {
	// If the duration is negative, capture that in underflow.
	if duration < 0 {
		h.underflow.Add(1)
		return
	}
	// bucketBit is the target bit for the bucket which is usually the

  static long toNanosSaturated(Duration duration) {
    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for
    // durations longer than approximately +/- 292 years).
    try {
      return duration.toNanos();
    } catch (ArithmeticException tooBig) {
      return duration.isNegative() ? Long.MIN_VALUE : Long.MAX_VALUE;
    }
  }

  private Internal() {}

  static long toNanosSaturated(Duration duration) {
    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for
    // durations longer than approximately +/- 292 years).
    try {
      return duration.toNanos();
    } catch (ArithmeticException tooBig) {
      return duration.isNegative() ? Long.MIN_VALUE : Long.MAX_VALUE;
    }
  }

  private Internal() {}

		h.MaxBucket = bucket
	}
	h.Count++
}

// BucketMin returns the minimum duration value for a provided bucket.
func (h *TimeHistogram) BucketMin(bucket int) time.Duration {
	return time.Duration(math.Exp(float64(bucket) * logDiv))
}

// ToHTML renders the histogram as HTML.
func (h *TimeHistogram) ToHTML(urlmaker func(min, max time.Duration) string) template.HTML {
	if h == nil || h.Count == 0 {
		return template.HTML("")
	}