},
          "createdTime" : {
            "type" : "long"
          },
          "queries" : {
            "type" : "keyword"
          },
          "term" : {
            "type" : "keyword"
          },
          "updatedBy" : {
            "type" : "keyword"
          },
          "updatedTime" : {
            "type" : "long"
          },
          "virtualHost" : {
            "type" : "keyword"

    private final AtomicLong bytesEncrypted = new AtomicLong(0);
    private long encryptionStartTime = System.currentTimeMillis();

    // Configurable key rotation limits with defaults
    private volatile long keyRotationBytesLimit = 1L << 30; // Default: 1GB
    private volatile long keyRotationTimeLimit = 24 * 60 * 60 * 1000L; // Default: 24 hours

    // Rotation metrics

    @Override
    protected void update(byte[] bytes, int off, int len) {
      checksum.update(bytes, off, len);
    }

    @Override
    public HashCode hash() {
      long value = checksum.getValue();
      if (bits == 32) {
        /*
         * The long returned from a 32-bit Checksum will have all 0s for its second word, so the
         * cast won't lose any information and is necessary to return a HashCode of the correct
         * size.

     * Default timeout for durable handles (2 minutes)
     */
    public static final long DEFAULT_DURABLE_TIMEOUT = 120000;

    /**
     * Maximum timeout for durable handles (5 minutes)
     */
    public static final long MAX_DURABLE_TIMEOUT = 300000;

    /**
     * Persistent handles have infinite timeout
     */
    public static final long PERSISTENT_TIMEOUT = 0;

    /**
     * Private constructor to prevent instantiation

   * @see FileChannel#map(MapMode, long, long)
   * @since 2.0
   */
  public static MappedByteBuffer map(File file) throws IOException {
    checkNotNull(file);
    return map(file, MapMode.READ_ONLY);
  }

  /**
   * Fully maps a file in to memory as per {@link
   * FileChannel#map(java.nio.channels.FileChannel.MapMode, long, long)} using the requested {@link
   * MapMode}.
   *

/**
 * @author FreeGen
 */
public class Group extends BsGroup {

    private static final long serialVersionUID = 1L;

    private Map<String, String> attributes;

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    public String getId() {
        return asDocMeta().id();

    return new GwtLongAddable();
  }

  private static final class GwtLongAddable implements LongAddable {
    private long value;

    public void increment() {
      value++;
    }

    public void add(long x) {
      value += x;
    }

    public long sum() {
      return value;
    }
  }

   * the head of the list.
   */

  /** Returns the time that this entry was last accessed, in ns. */
  @SuppressWarnings("GoodTime")
  long getAccessTime();

  /** Sets the entry access time in ns. */
  @SuppressWarnings("GoodTime") // b/122668874
  void setAccessTime(long time);

  /** Returns the next entry in the access queue. */
  ReferenceEntry<K, V> getNextInAccessQueue();

 * sectors per allocation unit, and bytes per sector for a file system volume.
 */
public class FileFsSizeInformation implements AllocInfo {

    private long alloc; // Also handles SmbQueryFSSizeInfo
    private long free;
    private int sectPerAlloc;
    private int bytesPerSect;

    /**
     * Default constructor for decoding file system size information.
     */

  }

  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) {