newParams = rewriter.rewrite(newParams);
        }
        return newParams;
    }

    public void addRewriter(final SearchRequestParamsRewriter rewriter) {
        searchRequestParamsRewriters = Arrays.copyOf(searchRequestParamsRewriters, searchRequestParamsRewriters.length + 1);
        searchRequestParamsRewriters[searchRequestParamsRewriters.length - 1] = rewriter;
    }

    public interface SearchRequestParamsRewriter {

    ByteSource fewerBytes = new TestByteSource(newPreFilledByteArray(bytes.length / 2));
    assertFalse(source.contentEquals(fewerBytes));

    byte[] copy = bytes.clone();
    copy[9876] = 1;
    ByteSource oneByteOff = new TestByteSource(copy);
    assertFalse(source.contentEquals(oneByteOff));
  }

  public void testSlice() throws IOException {
    // Test preconditions

    private final String name;

    NamedObject(String name) {
      this.name = Preconditions.checkNotNull(name);
    }

    NamedObject addPeers(String... names) {
      peerNames.addAll(ImmutableList.copyOf(names));
      return this;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof NamedObject) {
        NamedObject that = (NamedObject) obj;

  public static <K extends Comparable, V> TreeRangeMap<K, V> create() {
    return new TreeRangeMap<>();
  }

  @SuppressWarnings("unchecked")
  public static <K extends Comparable<?>, V> TreeRangeMap<K, V> copyOf(
      RangeMap<K, ? extends V> rangeMap) {
    if (rangeMap instanceof TreeRangeMap) {
      NavigableMap<Cut<K>, RangeMapEntry<K, V>> entriesByLowerBound = Maps.newTreeMap();

      disallowPrimitiveType(bounds, "bound for type variable");
      this.genericDeclaration = checkNotNull(genericDeclaration);
      this.name = checkNotNull(name);
      this.bounds = ImmutableList.copyOf(bounds);
    }

    public Type[] getBounds() {
      return toArray(bounds);
    }

    public D getGenericDeclaration() {
      return genericDeclaration;
    }

      }
      builder.duplicateKey = duplicateKey;
      hashTable = hashTableAndSizeAndDuplicate[0];
      n = (Integer) hashTableAndSizeAndDuplicate[1];
      alternatingKeysAndValues = Arrays.copyOf(alternatingKeysAndValues, n * 2);
    } else {
      hashTable = hashTablePlus;
    }
    return new RegularImmutableMap<K, V>(hashTable, alternatingKeysAndValues, n);
  }

  /**

        if (logger.isDebugEnabled()) {
            logger.debug("Load {}", searcher.getClass().getSimpleName());
        }
        final RankFusionSearcher[] newSearchers = Arrays.copyOf(searchers, searchers.length + 1);
        newSearchers[newSearchers.length - 1] = searcher;
        searchers = newSearchers;
        synchronized (this) {
            if (executorService == null) {

    // would cause one to be evicted.
    return new CacheBuilderFactory()
        .withKeyStrengths(ImmutableSet.of(Strength.STRONG, Strength.WEAK))
        .withValueStrengths(ImmutableSet.copyOf(Strength.values()))
        .withConcurrencyLevels(ImmutableSet.of(1, 4, 16, 64))
        .withMaximumSizes(ImmutableSet.of(400, 1000))
        .withInitialCapacities(ImmutableSet.of(0, 1, 10, 100, 1000))

      return new byte[0];
    }
    byte[] result = bufs.remove();
    if (result.length == totalLen) {
      return result;
    }
    int remaining = totalLen - result.length;
    result = Arrays.copyOf(result, totalLen);
    while (remaining > 0) {
      byte[] buf = bufs.remove();
      int bytesToCopy = min(remaining, buf.length);
      int resultOffset = totalLen - remaining;

      bufferSize = k;
      threshold = buffer[k - 1];
    }
    // Up to bufferSize, all elements of buffer are real Ts (not null unless T includes null)
    T[] topK = Arrays.copyOf(castBuffer, bufferSize);
    // we have to support null elements, so no ImmutableList for us
    return unmodifiableList(asList(topK));
  }