Adds full new case for the argument that are of specific classes (matched by instanceOf, null is a wildcard).
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();
	}
935087
@Nonnull
	public <V extends T> LToDblFunctionBuilder<T> aCase(Class<V> argC, LToDblFunction<V> function) {
		PartialCaseWithDblProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

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

		pc.evaluate(function);
		return self();
	}
1148139
@Nonnull
	public <V extends T> LToSrtFunctionBuilder<T> aCase(Class<V> argC, LToSrtFunction<V> function) {
		PartialCaseWithSrtProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		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();
	}
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
221281
public static <T extends Case1<A>, A> Case1Extractor<T, A> create(Class<T> caseClazz) {
    return new Case1Extractor<>(caseClazz);
  }
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();
	}
810386
public final PCB aCase(@Nonnull P casePredicate, @Nonnull F caseFunction) {
        cases.add(new Case<>(casePredicate, caseFunction));
        return self();
    }
351584
public static <T> T mapToBeanIgnoreCase(Map<?, ?> map, Class<T> beanClass, boolean isIgnoreError) {
		return fillBeanWithMapIgnoreCase(map, ReflectUtil.newInstance(beanClass), isIgnoreError);
	}
632293
@Nonnull
	public <V extends T> LConsumerBuilder<T> casesOf(Class<V> argC, Consumer<LConsumerBuilder<V>> pcpConsumer) {
		PartialCase.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.specifySubCases((Consumer) pcpConsumer);
		return self();
	}
1363130
@Nonnull
	public <V extends T> LConsumerBuilder<T> aCase(Class<V> argC, LConsumer<V> function) {
		PartialCase.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
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();
	}
521748
public static Class<?> getTypeArgument(Class<?> clazz, int index) {
		final Type argumentType = TypeUtil.getTypeArgument(clazz, index);
		if (null != argumentType && argumentType instanceof Class) {
			return (Class<?>) argumentType;
		}
		return null;
	}
696017
@Nonnull
	public <V1 extends T1, V2 extends T2> LBiObjFltConsumerBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, LBiObjFltConsumer<V1, V2> function) {
		PartialCase.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
135812
@Nonnull
	public <V1 extends T1, V2 extends T2> LBiObjDblConsumerBuilder<T1, T2> casesOf(Class<V1> argC1, Class<V2> argC2, Consumer<LBiObjDblConsumerBuilder<V1, V2>> pcpConsumer) {
		PartialCase.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.specifySubCases((Consumer) pcpConsumer);
		return self();
	}
769149
public void addCase(SwitchCase switchCase) {
        assertNotNull(switchCase);
        if (cases == null) {
            cases = new ArrayList<SwitchCase>();
        }
        cases.add(switchCase);
        switchCase.setParent(this);
    }