Adds full new case for the argument that are of specific classes (matched by instanceOf, null is a wildcard).
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();
	}
714532
public static <T extends Case2<A, B>, A, B> Case2Extractor<T, A, B> create(Class<T> caseClazz) {
    return new Case2Extractor<>(caseClazz);
  }
713892
@Nonnull
	public <V1 extends T1, V2 extends T2> LTieConsumerBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC3, LTieConsumer<V1, V2> function) {
		PartialCase.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC3 == null || argC3.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
980676
public final PC inCase(@Nonnull P casePredicate) {
        Null.nonNullArg(casePredicate, "casePredicate");
        return partialCaseFactoryMethod(casePredicate);
    }
836329
@Nonnull
	public <V extends T> LObjBiIntPredicateBuilder<T> casesOf(Class<V> argC1, Consumer<LObjBiIntPredicateBuilder<V>> pcpConsumer) {
		PartialCaseWithBoolProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)));

		pc.specifySubCases((Consumer) pcpConsumer);
		return self();
	}
810386
public final PCB aCase(@Nonnull P casePredicate, @Nonnull F caseFunction) {
        cases.add(new Case<>(casePredicate, caseFunction));
        return self();
    }
299004
@Nonnull
	public <V extends T> LOiToFltFunctionBuilder<T> aCase(Class<V> argC1, LOiToFltFunction<V> function) {
		PartialCaseWithFltProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)));

		pc.evaluate(function);
		return self();
	}
1278772
def _active_case(self, value: ObjectValue) -> Optional["CaseNode"]:
        """"""
        for c in self.children:
            for cc in c.data_children():
                if cc.iname() in value:
                    return c
738036
@Nonnull
	public <V1 extends T1, V2 extends T2> LBiObjSrtPredicateBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, LBiObjSrtPredicate<V1, V2> function) {
		PartialCaseWithBoolProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
351584
public static <T> T mapToBeanIgnoreCase(Map<?, ?> map, Class<T> beanClass, boolean isIgnoreError) {
		return fillBeanWithMapIgnoreCase(map, ReflectUtil.newInstance(beanClass), isIgnoreError);
	}
144484
public final <T> void addArgument(Class<T> cls, String name)
    {
        if (map.containsKey(name))
        {
            throw new IllegalArgumentException(name+" is already added as option");
        }
        if (hasArrayArgument)
        {
            throw new IllegalArgumentException("no argument allowed after array argument");
        }
        types.add(cls);
        names.add(name);
        if (cls.isArray())
        {
            hasArrayArgument = true;
        }
    }
1276921
@Nonnull
	public <V1 extends T1, V2 extends T2> LObjIntObjFunctionBuilder<T1, T2, R> aCase(Class<V1> argC1, Class<V2> argC3, LObjIntObjFunction<V1, V2, R> function) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC3 == null || argC3.isInstance(a2)));

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

		pc.evaluate(function);
		return self();
	}
1140003
public CaseForEqBuilder<T> when(Expression<? extends T> other) {
        return new CaseForEqBuilder<T>(mixin, other);
    }
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();
	}
370638
public static <T extends Case2<A, B>, A, B> DecomposableMatchBuilder2<T, A, B> case2(
      Class<T> clazz, MatchesAny<A> a, MatchesAny<B> b) {
    List<Matcher<Object>> matchers = Lists.of(ArgumentMatchers.any(), ArgumentMatchers.any());
    return new DecomposableMatchBuilder2<T, A, B>(
        matchers, Tuple2.of(0, 1), new Case2FieldExtractor<>(clazz));
  }
419357
public static <T> Case<T> matchCase(Supplier<Boolean> condition ,
                                      Supplier<Result<T>> value) {
    return new Case<>(condition , value);
  }