"properties": {
    "@timestamp": {
      "type": "date",
      "format": "epoch_millis"
    },
    "docFreq": {
      "type": "long"
    },
    "fields": {
      "type": "keyword"
    },
    "kinds": {
      "type": "keyword"
    },
    "queryFreq": {
      "type": "long"
    },
    "roles": {
      "type": "keyword"
    },
    "languages": {
      "type": "keyword"
    },
    "score": {

public abstract class AbstractConfigHelper {

    protected long reloadInterval = 1000L;

    public void update() {
        CommonPoolUtil.execute(this::load);
    }

    protected void waitForNext() {
        if (reloadInterval > 0) {
            ThreadUtil.sleep(reloadInterval);
        }
    }

    public abstract int load();

    public void setReloadInterval(final long reloadInterval) {

    @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;
    }