Create a new {@link GenericResponseBuilder} for a not acceptable response.

@param variants list of variants that were available
@return a new builder
182966
public static <T> GenericResponseBuilder<T> notAcceptable(List<Variant> variants) {
    return GenericResponses.<T>status(Response.Status.NOT_ACCEPTABLE).variants(variants);
  }
266111
@Nonnull
	public static <T> LObjCharPredicateBuilder<T> objCharPredicate(Consumer<LObjCharPredicate<T>> consumer) {
		return new LObjCharPredicateBuilder(consumer);
	}
101248
protected final ClientBuilder newClientBuilder(String uri, Consumer<ClientBuilder> customizer) {
        final ClientBuilder builder = new ClientBuilder(uri);
        customizer.accept(builder);
        clientConfigurator.configure(builder);
        builder.factory(clientFactory());
        return builder;
    }
164637
public GenericResponseBuilder<T> replaceAll(MultivaluedMap<String, Object> headers) {
    rawBuilder.replaceAll(headers);
    return this;
  }
920750
public static <T> GenericResponseBuilder<T> ok(T entity, MediaType type) {
    return ok(entity).type(type);
  }
578662
public static RequestOptions.RequestOptionsBuilder builder(
            @Nullable String publishableApiKey,
            @NonNull @RequestType String requestType) {
        return new RequestOptions.RequestOptionsBuilder(
                publishableApiKey,
                requestType);
    }
575038
public static <K extends Comparable<?>, V> Builder<K, V> builder() {
    return new Builder<K, V>();
  }
276667
public static GenericResponseBuilderFactory newInstance() {
    ServiceLoader<GenericResponseBuilderFactory> clientBuilderFactoryLoader =
        ServiceLoader.load(GenericResponseBuilderFactory.class);

    Iterator<GenericResponseBuilderFactory> iterator = clientBuilderFactoryLoader.iterator();

    if (!iterator.hasNext()) {
      throw new IllegalStateException(
          "An implementation of GenericResponseBuilderFactory was not found");
    }

    return iterator.next();
  }
240057
public static Builder v2CompatibleBuilder(String name) {
        return new Builder(name, V2CompatibleMarshallerSet.marshallers(),
                           V2CompatibleMarshallerSet.setMarshallers(),
                           StandardUnmarshallerSet.unmarshallers(),
                           StandardUnmarshallerSet.setUnmarshallers());
    }
255513
public JSType createUnionType(JSType... variants) {
    UnionTypeBuilder builder = UnionTypeBuilder.create(this);
    for (JSType type : variants) {
      builder.addAlternate(type);
    }
    return builder.build();
  }
886326
public static <T> GenericResponseBuilder<T> fromResponse(GenericResponse<T> response) {
    GenericResponseBuilder<T> builder =
        genericResponseBuilderFactory.create(response.getStatus(), response.body());

    for (String headerName : response.getHeaders().keySet()) {
      List<Object> headerValues = response.getHeaders().get(headerName);
      for (Object headerValue : headerValues) {
        builder.header(headerName, headerValue);
      }
    }
    return builder;
  }
1234796
@Nonnull
	public static <T1, T2, R> LBiObjFltFunctionBuilder<T1, T2, R> biObjFltFunction() {
		return new LBiObjFltFunctionBuilder();
	}
964743
public GenericResponseBuilder<T> header(String name, Object value) {
    rawBuilder.header(name, value);
    return this;
  }
765245
public static <T extends ResourceId> Builder<T> newBuilder(Status status) {
    return new Builder<T>().setStatus(status);
  }
962394
@Nonnull
	public static <T, R> LObjIntCharFunctionBuilder<T, R> objIntCharFunction(Consumer<LObjIntCharFunction<T, R>> consumer) {
		return new LObjIntCharFunctionBuilder(consumer);
	}
526821
public static Predicate<Variant> getStrictVariantPredicate(final long start, String fields) {
    Preconditions
    .checkArgument(Strings.isNullOrEmpty(fields)
        || VARIANT_FIELD_PATTERN.matcher(fields).matches(),
        "Insufficient fields requested in partial response. At a minimum "
            + "include 'variants(start)' to enforce a strict shard boundary.");
    return new Predicate<Variant>() {
      @Override
      public boolean apply(Variant variant) {
        return variant.getStart() >= start;
      }
    };
  }
1368001
public static <T> GenericResponseBuilder<T> status(Response.StatusType status) {
    if (status == null) {
      throw new NullPointerException("status:null");
    }

    return status(status.getStatusCode());
  }