@Required
    @Size(max = 1000)
    public String id;

    @Size(max = 1000)
    public String updatedBy;

    @ValidateTypeFailure
    public Long updatedTime;

    @Required
    @ValidateTypeFailure
    public Long versionNo;

            if (d != null) {
                return d;
            }
            return new Double(0);
        } else if (type == long.class) {
            final Long l = LongConversionUtil.toLong(o);
            if (l != null) {
                return l;
            }
            return Long.valueOf(0);
        } else if (type == float.class) {
            final Float f = FloatConversionUtil.toFloat(o);
            if (f != null) {

      if (queue.futureTasks.isEmpty()) {
        readyQueues.removeAt(i)
      }
    }
  }

  interface Backend {
    fun nanoTime(): Long

    fun coordinatorNotify(taskRunner: TaskRunner)

    fun coordinatorWait(
      taskRunner: TaskRunner,
      nanos: Long,
    )

    fun <T> decorate(queue: BlockingQueue<T>): BlockingQueue<T>

    fun execute(
      taskRunner: TaskRunner,

import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;


/**
 * 
 */
public class SmbComReadAndX extends AndXServerMessageBlock {

    private long offset;
    private int fid;
    int openTimeout;
    int maxCount, minCount, remaining;


    /**
     * 
     * @param config
     */
    public SmbComReadAndX ( Configuration config ) {

 */

package jcifs.dcerpc.ndr;


@SuppressWarnings ( "javadoc" )
public class NdrHyper extends NdrObject {

    public long value;


    public NdrHyper ( long value ) {
        this.value = value;
    }


    @Override
    public void encode ( NdrBuffer dst ) throws NdrException {
        dst.enc_ndr_hyper(this.value);
    }

  private static final long SMALL_TIMEOUT_MILLIS = 10;

  /** How long to wait when determining that a thread is blocked if we expect it to be blocked. */
  private static final long EXPECTED_HANG_DELAY_MILLIS = 75;

  /**
   * How long to wait when determining that a thread is blocked if we DON'T expect it to be blocked.
   */
  private static final long UNEXPECTED_HANG_DELAY_MILLIS = 10000;

  /**

    "aliases" : { },
    "mappings" : {
      "file_authentication" : {
        "properties" : {
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "fileConfigId" : {
            "type" : "keyword"
          },
          "hostname" : {
            "type" : "keyword"
          },
          "parameters" : {

         */
        public Map<String, Long> getValueCountMap() {
            return valueCountMap;
        }

        /**
         * @return the name
         */
        public String getName() {
            return name;
        }

    }

    /**
     * @return the queryCountMap
     */
    public Map<String, Long> getQueryCountMap() {
        return queryCountMap;
    }

  }

  private void setSuccessor(int entry, int succ) {
    long succMask = (~0L) >>> 32;
    setLink(entry, (link(entry) & ~succMask) | ((succ + 1) & succMask));
  }

  private void setPredecessor(int entry, int pred) {
    long predMask = ~0L << 32;
    setLink(entry, (link(entry) & ~predMask) | ((long) (pred + 1) << 32));
  }

  private void setSucceeds(int pred, int succ) {

    "aliases" : { },
    "mappings" : {
      "label_type" : {
        "properties" : {
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "excludedPaths" : {
            "type" : "keyword"
          },
          "includedPaths" : {
            "type" : "keyword"
          },
          "name" : {