*/
    public LruHashMap(final int limitSize) {
        this(limitSize, DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    /**
     * {@link LruHashMap}を作成します。
     *
     * @param limitSize
     *            エントリ数の上限
     * @param initialCapacity
     *            初期容量
     * @param loadFactor
     *            負荷係数
     */
    public LruHashMap(final int limitSize, final int initialCapacity, final float loadFactor) {

        this.type = type;
    }

    public boolean include(Artifact artifact) {
        return type.equals(artifact.getType());
    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + type.hashCode();
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;

			Optional:    true,
			Type:        "int",
		},
		config.HelpKV{
			Key:         ExcessFolders,
			Description: `alert beyond this many sub-folders per folder in an erasure set` + defaultHelpPostfix(ExcessFolders),
			Optional:    true,
			Type:        "int",
		},
	}

		TransitionWorkers: 100,
	},
}

type ilmConfig struct {
	mu  sync.RWMutex
	cfg ilm.Config
}

func (c *ilmConfig) getExpirationWorkers() int {
	c.mu.RLock()
	defer c.mu.RUnlock()

	return c.cfg.ExpirationWorkers
}

func (c *ilmConfig) getTransitionWorkers() int {
	c.mu.RLock()
	defer c.mu.RUnlock()

	return c.cfg.TransitionWorkers
}

func (c *ilmConfig) update(cfg ilm.Config) {
	c.mu.Lock()

  @get:JvmName("maxAgeSeconds") val maxAgeSeconds: Int,
  /**
   * The "s-maxage" directive is the max age for shared caches. Not to be confused with "max-age"
   * for non-shared caches, As in Firefox and Chrome, this directive is not honored by this cache.
   */
  @get:JvmName("sMaxAgeSeconds") val sMaxAgeSeconds: Int,
  val isPrivate: Boolean,
  val isPublic: Boolean,

     * @param out
     *            出力ストリーム
     * @return コピーしたバイト数
     */
    protected static int copyInternal(final InputStream in, final OutputStream out) {
        try {
            final byte[] buf = new byte[DEFAULT_BUF_SIZE];
            int len;
            int amount = 0;
            while ((len = in.read(buf)) != -1) {
                out.write(buf, 0, len);
                amount += len;

        doDelete(entity, null);
    }

    public int queryDelete(CBCall<UserCB> cbLambda) {
        return doQueryDelete(createCB(cbLambda), null);
    }

    public int[] batchInsert(List<User> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<User> list, RequestOptionCall<BulkRequestBuilder> call) {

            return content;
        }

        final int maxAlphanumTermSize = getMaxAlphanumTermSize();
        final int maxSymbolTermSize = getMaxSymbolTermSize();
        final boolean duplicateTermRemoved = isDuplicateTermRemoved();
        final int[] spaceChars = getSpaceChars();
        try (final Reader reader = new StringReader(content)) {

/** A scripted response to be replayed by the mock web server. */
@ExperimentalOkHttpApi
class MockResponse {
  /** Returns the HTTP response line, such as "HTTP/1.1 200 OK". */
  val status: String

  val code: Int
    get() {
      val statusParts = status.split(' ', limit = 3)
      require(statusParts.size >= 2) { "Unexpected status: $status" }
      return statusParts[1].toInt()
    }

  val message: String
    get() {

  }

  private enum LexicographicalComparator implements Comparator<byte[]> {
    INSTANCE;

    @Override
    public int compare(byte[] left, byte[] right) {
      int minLength = Math.min(left.length, right.length);
      for (int i = 0; i < minLength; i++) {
        int result = Byte.compare(left[i], right[i]);
        if (result != 0) {
          return result;
        }
      }