Adds full new case for the argument that are of specific classes (matched by instanceOf, null is a wildcard).
543004
@Nonnull
	public <V extends T> PredicateBuilder<T> aCase(Class<V> argC, Predicate<V> function) {
		PartialCaseWithBoolProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
1328123
@Nonnull
	public <V extends T> LToFltFunctionBuilder<T> aCase(Class<V> argC, LToFltFunction<V> function) {
		PartialCaseWithFltProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		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();
	}
646971
@Nonnull
	public <V1 extends T1, V2 extends T2, V3 extends T3> LTriFunctionBuilder<T1, T2, T3, R> aCase(Class<V1> argC1, Class<V2> argC2, Class<V3> argC3, LTriFunction<V1, V2, V3, R> function) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)) && (argC3 == null || argC3.isInstance(a3)));

		pc.evaluate(function);
		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;
	}
1149293
static <T> Object[] arguments(final Class<T> klass, final T instance,
                                  final Class<?>[] types,
                                  final String[] literals)
            throws ReflectiveOperationException {
        final Object[] arguments = new Object[literals.length];
        for (int i = 0; i < literals.length; i++) {
            if ("null".equals(literals[i])) {
                arguments[i] = null;
                continue;
            }
            if (literals[i].startsWith(":")) {
                final String name = literals[i].substring(1);
                final Field field = field(klass, name);
                if (!field.isAccessible()) {
                    field.setAccessible(true);
                }
                arguments[i] = field.get(instance);
                continue;
            }
            if (types[i] == String.class) {
                arguments[i] = literals[i];
                continue;
            }
            if (types[i].isPrimitive()) {
                types[i] = wrapper(types[i]);
            }
            arguments[i] = types[i]
                    .getMethod("valueOf", String.class)
                    .invoke(null, literals[i]);
        }
        return arguments;
    }
1005841
static <T> T newInstance(final Class<?> clazz, final Class<?>[] argumentTypes, final Object[] arguments,
        final Class<T> expectedType) {
        // Precondition checks
        if (clazz == null) {
            throw new IllegalArgumentException("Class must be specified");
        }
        if (argumentTypes == null) {
            throw new IllegalArgumentException("ArgumentTypes must be specified. Use empty array if no arguments");
        }
        if (arguments == null) {
            throw new IllegalArgumentException("Arguments must be specified. Use empty array if no arguments");
        }
        if (expectedType == null) {
            throw new IllegalArgumentException("Expected type must be specified");
        }

        // Get the ctor
        final Constructor<?> constructor;
        try {
            constructor = getConstructor(clazz, argumentTypes);
        } catch (final NoSuchMethodException e) {
            throw new RuntimeException("Could not create new instance of " + clazz + " using ctor argument types "
                + Arrays.asList(argumentTypes), e);
        }

        // Create the instance
        final Object obj;
        try {
            obj = constructor.newInstance(arguments);
        } catch (final Exception e) {
            throw new RuntimeException("Could not create a new instance of " + clazz + " using arguments "
                + Arrays.asList(arguments), e);
        }

        // Cast
        try {
            return expectedType.cast(obj);
        } catch (final ClassCastException cce) {
            // Reconstruct so we get some useful information
            throw new ClassCastException("Incorrect expected type, " + expectedType.getName() + ", defined for "
                + obj.getClass().getName());
        }
    }
86927
@Nonnull
	public <V extends T> LOiToDblFunctionBuilder<T> aCase(Class<V> argC1, LOiToDblFunction<V> function) {
		PartialCaseWithDblProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)));

		pc.evaluate(function);
		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();
	}
1204419
@Nonnull
	public <V1 extends T1, V2 extends T2> LTieFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC3, LTieFunction<V1, V2> function) {
		PartialCaseWithIntProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC3 == null || argC3.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
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();
	}
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();
	}
579582
@Nonnull
	public <V extends T> LUnaryOperatorBuilder<T> aCase(Class<V> argC, LUnaryOperator<V> function) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
221281
public static <T extends Case1<A>, A> Case1Extractor<T, A> create(Class<T> caseClazz) {
    return new Case1Extractor<>(caseClazz);
  }
860787
public final PCB aCase(Consumer<CaseBuilder<P, PC>> caseBuilderConsumer) {
        Null.nonNullArg(caseBuilderConsumer, "caseBuilderConsumer");
        caseBuilderConsumer.accept(new CaseBuilder<>(this::partialCaseFactoryMethod));
        return self();
    }
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();
	}
915274
public void addMatch(String name, PseudoClassType pseudoClass)
    {
        if (names == null)
            names = new HashMap<String, Set<PseudoClassType>>();
        
        Set<PseudoClassType> classes = names.get(name);
        if (classes == null)
        {
            classes = new HashSet<PseudoClassType>(2);
            names.put(name, classes);
        }
        classes.add(pseudoClass);
    }