if (lastTime == null) {
                return;
            }
            synchronized (lastTime) {
                while (true) {
                    final long currentTime = SystemUtil.currentTimeMillis();
                    final long delayTime = lastTime.get() + delayMillisBeforeProcessing - currentTime;
                    if (delayTime <= 0) {
                        lastTime.set(currentTime);

   *
   * TODO: make this inline once this is fixed: https://github.com/oracle/graal/issues/3466
   */
  fun schedule(
    name: String,
    delayNanos: Long = 0L,
    block: () -> Long,
  ) {
    schedule(
      object : Task(name) {
        override fun runOnce(): Long {
          return block()
        }
      },
      delayNanos,
    )
  }

  /**
   * Executes [block] once on a task runner thread.

class Trans2SetFileInformation extends SmbComTransaction {

    static final int SMB_FILE_BASIC_INFO = 0x101;

    private int fid;
    private int attributes;
    private long createTime, lastWriteTime;

    Trans2SetFileInformation( int fid, int attributes, long createTime, long lastWriteTime ) {
        this.fid = fid;
        this.attributes = attributes;
        this.createTime = createTime;
        this.lastWriteTime = lastWriteTime;

 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
interface LongAddable {
  void increment();

  void add(long x);

  long sum();

   *
   * <p>See {@link #verify(boolean, String, Object...)} for details.
   *
   * @since 23.1 (varargs overload since 17.0)
   */
  public static void verify(boolean expression, String errorMessageTemplate, long p1, long p2) {
    if (!expression) {
      throw new VerifyException(lenientFormat(errorMessageTemplate, p1, p2));
    }
  }

  /**

/**
 * @param <ENTITY> The type of entity.
 * @author ESFlute (using FreeGen)
 */
public class EsPagingResultBean<ENTITY> extends PagingResultBean<ENTITY> {

    private static final long serialVersionUID = 1L;

    protected long took;
    private int totalShards;
    private int successfulShards;
    private int failedShards;
    private TotalHits totalHits;
    private Aggregations aggregations;

     * @throws CIFSException
     * @throws jcifs.smb.SmbUnsupportedOperationException
     *             if CAP_NT_SMBS is unavailable
     */
    void setFileTimes ( long createTime, long lastModified, long lastAccess ) throws CIFSException;


    /**
     * Set the last access time of the file. The time is specified as milliseconds
     * from Jan 1, 1970 which is the same as that which is returned by the

      }

      var minFreshMillis: Long = 0
      if (requestCaching.minFreshSeconds != -1) {
        minFreshMillis = SECONDS.toMillis(requestCaching.minFreshSeconds.toLong())
      }

      var maxStaleMillis: Long = 0
      if (!responseCaching.mustRevalidate && requestCaching.maxStaleSeconds != -1) {

   * > GeneralizedTime.
   */
  internal val time: DerAdapter<Long> =
    object : DerAdapter<Long> {
      override fun matches(header: DerHeader): Boolean {
        return Adapters.UTC_TIME.matches(header) || Adapters.GENERALIZED_TIME.matches(header)
      }

      override fun fromDer(reader: DerReader): Long {
        val peekHeader =
          reader.peekHeader()

   * Returns a nonempty contiguous set containing all {@code long} values from {@code lower}
   * (inclusive) to {@code upper} (inclusive). (These are the same values contained in {@code
   * Range.closed(lower, upper)}.)
   *
   * @throws IllegalArgumentException if {@code lower} is greater than {@code upper}
   * @since 23.0
   */
  public static ContiguousSet<Long> closed(long lower, long upper) {