* limitations under the License.
 */

package com.google.common.testing;

import static com.google.common.base.Preconditions.checkNotNull;
import static java.util.Objects.requireNonNull;

import com.google.common.annotations.GwtCompatible;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

     *
     * @param modelName The model name.
     * @return This query builder.
     */
    public StoredLtrQueryBuilder modelName(final String modelName) {
        this.modelName = Objects.requireNonNull(modelName);
        return this;
    }

    /**
     * Gets the name of the featureset.
     *
     * @return The featureset name.
     */
    public String featureSetName() {

    static ArtifactCoordinatesFactoryRequest build(@Nonnull Session session, @Nonnull String coordinateString) {
        return ArtifactCoordinatesFactoryRequest.builder()
                .session(requireNonNull(session, "session"))
                .coordinateString(requireNonNull(coordinateString, "coordinateString"))
                .build();
    }

    @Nonnull

    static DependencyCoordinatesFactoryRequest build(
            @Nonnull Session session, @Nonnull ArtifactCoordinates coordinates) {
        return builder()
                .session(requireNonNull(session, "session cannot be null"))
                .groupId(requireNonNull(coordinates, "coordinates cannot be null")
                        .getGroupId())
                .artifactId(coordinates.getArtifactId())

  @Override
  @SuppressWarnings("unchecked")
  public E get(int index) {
    checkElementIndex(index, size);
    // requireNonNull is safe because we guarantee that the first `size` elements are non-null.
    return (E) requireNonNull(array[index]);
  }

  // TODO(lowasser): benchmark optimizations for equals() and see if they're worthwhile

  // redeclare to help optimizers with b/310253115

      RegularImmutableMap<K, V> empty = (RegularImmutableMap<K, V>) EMPTY;
      return empty;
    } else if (n == 1) {
      // requireNonNull is safe because the first `2*n` elements have been filled in.
      checkEntryNotNull(
          requireNonNull(alternatingKeysAndValues[0]), requireNonNull(alternatingKeysAndValues[1]));
      return new RegularImmutableMap<K, V>(null, alternatingKeysAndValues, 1);
    }

                    boolean embedded) {
                this.command = requireNonNull(command, "command");
                this.commandName = requireNonNull(commandName, "commandName");
                this.args = List.copyOf(requireNonNull(args, "args"));
                this.logger = requireNonNull(logger, "logger");
                this.messageBuilderFactory = requireNonNull(messageBuilderFactory, "messageBuilderFactory");

  }

  @Override
  public C first() {
    // requireNonNull is safe because we checked the range is not empty in ContiguousSet.create.
    return requireNonNull(range.lowerBound.leastValueAbove(domain));
  }

  @Override
  public C last() {
    // requireNonNull is safe because we checked the range is not empty in ContiguousSet.create.
    return requireNonNull(range.upperBound.greatestValueBelow(domain));
  }

          submittingTaskQueue.nextTask = task;
          // requireNonNull(delegate) is safe for reasons similar to requireNonNull(sequencer).
          submittingTaskQueue.nextExecutor = requireNonNull(delegate);
          delegate = null;
        } else {
          // requireNonNull(delegate) is safe for reasons similar to requireNonNull(sequencer).
          Executor localDelegate = requireNonNull(delegate);
          delegate = null;

      C columnKey = cell.getColumnKey();
      V value = cell.getValue();

      /*
       * These requireNonNull calls are safe because we construct the maps to hold all the provided
       * cells.
       */
      cellRowIndices[i] = requireNonNull(rowIndex.get(rowKey));
      Map<C, V> thisRow = requireNonNull(rows.get(rowKey));
      cellColumnInRowIndices[i] = thisRow.size();
      V oldValue = thisRow.put(columnKey, value);