Holding a Map of functions with differing number of args

I am trying to write a utility class that can take in a String and Class<?> and return back an Object that is really the typed instance of that String.

For example, if I have string "FALSE" and class "java.lang.Boolean", I want to return the typed Boolean.FALSE. Etc for other classes like String, Long, Int, Enum, etc.

I want to do this in a way that doesn't need too much re-writing when a new type is added. Currently I have a method with signature Object getTypedValue(Class<?> clazz, String value);.

From here, I thought I could use a Map<Class<?>, Function<String, Object>>. This works fine for cases like String and Boolean, but with the Enum case, I need the class name as well. So then the Map becomes Map<Class<?>, BiFunction<String, Class<?>, Object>>.

But most of the methods do not need the Class parameter. Have also found that a new FunctionalInterface like:

@FunctionalInterface
public interface OptionalClassFunction<T, CLAZZ, R> {
  
  R apply(T t, CLAZZ... clazz);

}

does not seem to work when I pass a method with only the T as the lambda.

e.g.

ImmutableMap.of(
  Boolean.class, Util::toBoolean
)

private Boolean toBoolean(String value);

does not work.

Any suggestions on how to so something like:

Map<Class<?>, WhateverFunction<String, MAYBE_A_CLASS, Object>> ?

Example methods would be:

  public static Boolean toBoolean(String value) {
    // derive bool
  }

  public static Enum toEnum(String value, Class<?> fieldType) {
    // derive enum
  }

Why would you need the class name for enums?

E.g. DayOfWeek is an enum, and like every other enum class, it has a valueOf(String name) method, so simply register this:

DayOfWeek.class, DayOfWeek::valueOf

If you don't like the valueOf method, e.g. because it is case-sensitive, and your toEnum method is better, then write a helper method to encapsulate that, e.g.

public static <T extends Enum<T>> Function<String, T> getEnumParser(Class<T> type) {
	return s -> toEnum(s, type);
}

public static <T extends Enum<T>> T toEnum(String value, Class<T> type) {
	for (T constant : type.getEnumConstants())
		if (constant.name().equalsIgnoreCase(value))
			return constant;
	throw new IllegalArgumentException("Unknown constant for enum " + type.getName() + ": \"" + value + "\"");
}

You then register it using:

DayOfWeek.class, Util.getEnumParser(DayOfWeek.class)

The helper is nice, but you don't really need it:

DayOfWeek.class, s -> Util.toEnum(s, DayOfWeek.class)

except that might confuse the compiler when used with ImmutableMap.of(...). The helper fixes that potential compiler inference problem.

> Any suggestions on how to so something like:
>
> Map<Class<?>, WhateverFunction<String, MAYBE_A_CLASS, Object>>

Always make it a BiFunction, and simply ignore the Class<?> parameter:

Map<Class<?>, BiFunction<String, Class<?>, Object>> map = Map.of(
        Boolean.class, (s,t) -> Util.toBoolean(s),
        Enum.class, Util::toEnum
);

Since the user of the map wouldn't know if the Class<?> parameter is needed, it would have to always pass the value, e.g.

Class<?> type = ...
String value = ...

Object obj = map.get(type).apply(value, type);

Simplified. You'd normally check for null after the get() call.

Of course, that won't work either, because the caller thinks the type is e.g. DayOfWeek, so if caller does type = DayOfWeek.class, the lookup would fail. Now suddenly the logic needed by the caller is getting complex.

Solution for that is to encapsulate the get-apply logic in a helper method, so you can substitute DayOfWeek.class with Enum.class for the map lookup, but if you do that, you might as well just build in straight support for enums, bypassing the map, and leave the map with Function.