Adds full new case for the argument that are of specific classes (matched by instanceOf, null is a wildcard).
481792
@Nonnull
	public <V1 extends T1, V2 extends T2> LToDblBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, LToDblBiFunction<V1, V2> function) {
		PartialCaseWithDblProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
1324302
@Nonnull
	public <V extends T> LObjBoolPredicateBuilder<T> aCase(Class<V> argC1, LObjBoolPredicate<V> function) {
		PartialCaseWithBoolProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)));

		pc.evaluate(function);
		return self();
	}
618414
private void ssApplyAllCaseFold(int flag, ApplyAllCaseFoldFunction fun, Object arg) {
        fun.apply(0xdf, SS, 2, arg);
    }
553214
@Nonnull
	public <V1 extends T1, V2 extends T2> LBiFunctionBuilder<T1, T2, R> aCase(Class<V1> argC1, Class<V2> argC2, LBiFunction<V1, V2, R> function) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
946491
@Nonnull
	public <V extends T> LToIntFunctionBuilder<T> aCase(Class<V> argC, LToIntFunction<V> function) {
		PartialCaseWithIntProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
1104994
public SwitchBuilder addCase(ImmutableList<Expression> caseLabels, Statement body) {
    Preconditions.checkState(!caseLabels.isEmpty(), "at least one case required");
    clauses.add(new Switch.CaseClause(caseLabels, body));
    return this;
  }
157288
public SwitchBuilder addCase(Expression caseLabel, Statement body) {
    clauses.add(new Switch.CaseClause(ImmutableList.of(caseLabel), body));
    return this;
  }
1296512
@Nonnull
	public <V1 extends T1, V2 extends T2> LToFltBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, LToFltBiFunction<V1, V2> function) {
		PartialCaseWithFltProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
1244598
@Nullable
  public static <ENUMTYPE extends Enum <ENUMTYPE> & IHasName> ENUMTYPE getFromNameCaseInsensitiveOrNull (@Nonnull final Class <ENUMTYPE> aClass,
                                                                                                         @Nullable final String sName)
  {
    return getFromNameCaseInsensitiveOrDefault (aClass, sName, null);
  }
1140003
public CaseForEqBuilder<T> when(Expression<? extends T> other) {
        return new CaseForEqBuilder<T>(mixin, other);
    }
978763
@Nonnull
	public <V extends T> LOiToSrtFunctionBuilder<T> aCase(Class<V> argC1, LOiToSrtFunction<V> function) {
		PartialCaseWithSrtProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)));

		pc.evaluate(function);
		return self();
	}
308599
private Object ignoreArgumentCase(final Object argument, final boolean shouldIgnoreCase) {
		if (!shouldIgnoreCase) {
			return argument;
		}
		if (argument instanceof String) {
			return ((String) argument).toLowerCase();
		}
		final List<String> lowered = new LinkedList<>();
		if (argument.getClass().isArray()) {
			final String[] array = (String[]) argument;
			for (final String string : array) {
				lowered.add(string.toLowerCase());
			}
		} else {
			@SuppressWarnings("unchecked")
			final Iterable<String> iterable = (Iterable<String>) argument;
			for (final Object object : iterable) {
				lowered.add(((String) object).toLowerCase());
			}
		}
		return lowered;
	}
1279783
public static <C> C getInstanceOf( Object argument,
                                       Class<C> expectedClass,
                                       String name ) {
        isInstanceOf(argument, expectedClass, name);
        return expectedClass.cast(argument);
    }
1119830
@Nonnull
	public <V extends T> LOiToByteFunctionBuilder<T> aCase(Class<V> argC1, LOiToByteFunction<V> function) {
		PartialCaseWithByteProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)));

		pc.evaluate(function);
		return self();
	}
494940
public static <T extends Case1<A>, A, EA extends A> DecomposableMatchBuilder0<T> case1(
      Class<T> clazz, DecomposableMatchBuilder0<EA> a) {
    List<Matcher<Object>> matchers = Lists.of(ArgumentMatchers.any());
    return new DecomposableMatchBuilder1<T, EA>(matchers, 0, new Case1FieldExtractor<>(clazz))
        .decomposeFirst(a);
  }
269676
@Nonnull
	public <V extends T> BinaryOperatorBuilder<T> aCase(Class<V> argC1, Class<V> argC2, BinaryOperator<V> function) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
434959
@Nonnull
	public <V1 extends T1, V2 extends T2> ToIntBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, ToIntBiFunction<V1, V2> function) {
		PartialCaseWithIntProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}