dynamic enum as method parameter

[Kenji Watanabe]

Hi,

I am breaking my head around this problem in which I need general code to use different enums.

At runtime I want to direct wich list to check by passing the enum name as method parameter ("Relatives" or "Connections").

The enums implement an interface that has a method List<String> getOptionTypes() to check if they contain the value.


I made a unit test to clarify my intentions, and that works when I use a defined enum instead of the desired dynamic part:

import static org.assertj.core.api.Assertions.assertThat;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class EnumOptionsTest {

	public interface EnumOptions {
		public static List<String> getOptionTypes() { return null; };
	}

	public enum Relatives implements EnumOptions {
		PARENT("1"),
		GRANDPARENT("2"),
		SIBLING("8"),
		SPOUSE("9");

		private String optionType;

		Relatives(String optionType) {
			this.optionType = optionType;
		}

		public static List<String> getOptionTypes() {
			return Arrays.stream(values()).map(v -> v.optionType).collect(Collectors.toList());
		}
	}

	public enum Connections implements EnumOptions {
		NEIGHBOUR("3"),
		COLLEGUE("4"),
		BOSS("6"),
		EMPLOYEE("7");

		private String optionType;

		Connections(String optionType) {
			this.optionType = optionType;
		}

		public static List<String> getOptionTypes() {
			return Arrays.stream(values()).map(v -> v.optionType).collect(Collectors.toList());
		}
	}

    @Test
    public void testEnums() throws ClassNotFoundException, IllegalAccessException, InstantiationException {

		String param = "Relatives";
		EnumOptions enumOptions = Class.forName(param).newInstance();//////////// HOW TO GET THE ENUM BY STRING OR CLASSNAME?

		List<String> options = Arrays.asList("3", "4", "7", "8");
		List<String> results = options.stream().filter(r -> enumOptions .getOptionTypes().contains(r)).collect(Collectors.toList());//////////// WORKS when you replace enumOptions by one of the enum names


		assertThat(results.size()).isEqualTo(1);
	}
}

Anybody having an idea to tackle this in a simple way?

[Piet Souris]

hi Kenji,

no, I could not think of a way to get the enum, given its name. But then again, do you need those two enums? Why not simply combine the two to just one enum?

While keeping the two enums, I tried to come up with a static Map<String, String> in the EnumOptionsTest class:

private static Map<String, String> toEnumValues = new HashMap<>();

And I filled it with:

    public enum Relatives implements EnumOptions {
        PARENT("1"),
        GRANDPARENT("2"),
        SIBLING("8"),
        SPOUSE("9");
        
        static {
            for (var s: Relatives.values()) toEnumValues.put(s.optionType, "Relations: "+ s.name());
        }
        ....
    }

and likewise for the Connections enum. And in the test at the end, I have:

public static void main(String... args) {
    var temp = Relatives.PARENT;   // to initialize filling of the Map
    var uemp = Connections.BOSS;   // likewise
    System.out.println(toEnumValues);
    var options = Arrays.asList("3", "4", "7", "8");
    options.stream()
        .filter(toEnumValues::containsKey)
        .forEach(s -> System.out.println(toEnumValues.get(s)))
    ;
}

[Kenji Watanabe]

Hi Piet, thank you, a Map could be a solution indeed.
Only it has to be passed in as a parameter, because the collection of values to check against may differ.
So one time it will be values representing Relatives, and in another scenario it will be Connections.

[Piet Souris]

Right. Well, one more attempt then:

I added this static method to your test class:

public static List<String> getOptionTypes(List<String> typesToSearch, String enumName) {
    return typesToSearch.stream()
        .filter(toEnumValues::containsKey)
        .map(s -> toEnumValues.get(s))
        .filter(s -> s.startsWith(enumName))
        .collect(toList())
    ;

}
and in the main method I have this code to test:

public static void main(String... args) {
    var temp = Relatives.PARENT;   // to initialize filling of the Map
    var uemp = Connections.BOSS;   // likewise
    var options = Arrays.asList("3", "4", "7", "8");
    var list = getOptionTypes(options, "Relatives");
    System.out.println(list);
}

[Junilu Lacar]

I not clear on what you're trying to achieve. It seems your intent is something like this:

List<EnumOptions> allValues = new ArrayList<>();
allValues.addAll(Connections.values());
allValues.addAll(Relatives.values());

List<EnumOptions> converted = toEnums(new String[] {"3", "4", "8", "7", "1", "9"}, allValues);

assertTrue(converted.contains(Connections.NEIGHBOUR));
assertTrue(converted.contains(Connections.COLLEGUE)); // sp. - COLLEAGUE
assertTrue(converted.contains(Relatives.SIBLING));
assertTrue(converted.contains(Connections.EMPLOYEE));
assertTrue(converted.contains(Relatives.PARENT));
assertTrue(converted.contains(Relatives.SPOUSE));

and you'd like to know how to implement a method like toEnums()?

[Kenji Watanabe]

Thank you guys for your help.
I guess the answer should be that you do not use enum classes to pass as parameters.
I think I'd keep the readability in one enum class, and have the calling method agnostic.
The enum constants are actually a fixed list so they can be joined indeed and the calling method should receive a subset based on the parameter value.
The calling method is ofcourse now stubbed in the test:

import static org.assertj.core.api.Assertions.assertThat;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class OptionsTest {

	public enum OptionsFilter {
		PARENT("1"),
		CHILD("2"),
		SPOUSE("3"),
		SIBLING("4"),
		OWNER("7"),
		CEO("8"),
		COLLEAGUE("9"),
		EMPLOYEE("10");

		private static final Map<String, String[]> subset = new HashMap<>();
		static {
			subset.put("relatives", new String[]{"parent", "child", "sibling"});
			subset.put("connections", new String[]{"owner","ceo","employee"});
		}

		private String val;

		OptionsFilter(String val) {
			this.val = val;
		}

		private static String getVal(String name){
			return OptionsFilter.valueOf(name.toUpperCase().trim()).val;
		}

		private static List<String> getList(String[] types) {
			return Arrays.stream(types).map(t -> getVal(t)).collect(Collectors.toList());
		}

		public static List<String> getList(String type) {
			return getList(subset.get(type));
		}
	}

	@Test
	public void testSubselection() {
		String param = "relatives";// this will be a filter directive as a method parameter
		List<String> externalList = Arrays.asList("3", "4", "7", "8");// this will be a list that is the result of another operation, not hardcoded like here
		
		List<String> filterSubset = OptionsFilter.getList(param);
		assertThat(filterSubset.size()).isEqualTo(3);
		assertThat(filterSubset.get(1)).isEqualTo("2");
		
		List<String> results = externalList.stream().filter(o -> filterSubset.contains(o)).collect(Collectors.toList());

		assertThat(results.size()).isEqualTo(1);
	}
}

What I do not like is that I have to use a Map but I guess there is no other way.

[Junilu Lacar]

Kenji Watanabe wrote:What I do not like is that I have to use a Map but I guess there is no other way.

I'm pretty sure there's a better way; I'm just not sure what exactly you're trying to do -- it's still unclear to me from the test you wrote.

[Junilu Lacar]

Here are some observations about the enum class design your test code suggests:

The API seems more focused on Strings rather than the OptionFilters type itself:
List<String> filterSubset = OptionsFilter.getList(param);
Why would I expect a List<String> from OptionsFilter.getList(String) instead of a List<OptionsFilter>? Seems like you're missing out on one of the points of using an enum class: to have a type-safe way of dealing with a limited set of values. A List<String> is far less limited than a List<OptionsFilter>.

This expectation is particularly baffling to me in the context of a enum type:
assertThat(filterSubset.get(1)).isEqualTo("2");
Why??? So you're expecting the list to be in a specific order? How would anyone who has not seen the implementation know this? Is this a white box test? Why would the order of items returned be of any concern?

In fact, there is no variable in the testSubselection() test that is declared as an OptionsFilter value. Everything is a String or List<String>. Why even use an enum then?

This really highlights your focus on Strings and List of Strings:
       private static String getVal(String name){            return OptionsFilter.valueOf(name.toUpperCase().trim()).val;        }
Why private? Why static? Why not have this instead:
       // an instance method of an OptionsFilter value        public String getVal(){            return this.val;        }
The fact that you made this method private static tells me your intent was solely to use it in service of the private getList(String[]) method.

What I see is a lot of unnecessary jumping through hoops to get something out of the OptionsFilter enum class that you shouldn't be expecting to get out of it. These are mis-assigned responsibilities.

Give me some time and I'll suggest a more enum-focused API.

[Kenji Watanabe]

Hi Junilu,
I must admit having little experience working with enums, but my intention is to have readability instead of numbers.
I really would like to use the strict typing of enums so I guess I must pursue a List<OptionsFilter>.
The assertion of the value was simply to be sure the code works, and had no functional meaning. Ofcourse it should be tested with an OptionsFilter constant.

[Junilu Lacar]

So here's the intent that I've gleaned from the test code:
Given a list of string "codes", I want to get a list of those codes that correspond to (either "relatives" or "connections")

First of all, I'd modify that to:
Given a list of string "codes", I want a list of corresponding OptionFilter enums that are (either "relatives" or "connections")

So the new intent, an API for an enum like OptionsFilter might be used like so:

List<String> codes = List.of("3", "4", "7", "8");  // externally provided in actual usage

// convert from list of "codes" to list of OptionsFilter enums
List<OptionsFilter> filterTypes = codes.stream()
   .map(this::toOptionFilter)
   .filter(Objects::nonNull)
   .collect(toList());

String subset = "relative" // or "connection"
Predicate<OptionsFilter> isRelative = getPredicate(subset);

// extract only the OptionsFilter enums that are "relatives"
List<OptionFilter> relatives = filterTypes.stream()
   .filter(isRelative)
   .collect(toList());

// convert from OptionsFilter enums to their "codes"
List<String> relativeCodes = relatives.stream()
   .map(OptionsFilter::getCode)
   .collect(toList());

To me, this API would set me down a path to assigning responsibilities in a much better way.

[Junilu Lacar]

Kenji Watanabe wrote:but my intention is to have readability instead of numbers.

If that is your intent, why would you have this assertion:
assertThat(filterSubset.get(1)).isEqualTo("2");
instead of this:
assertTrue(filterSubset.contains(OptionsFilter.CHILD));
Isn't the latter form more readable?

[Piet Souris]

I was also trying to get a simpler way. First, I added another field to the enums, like:

public enum OptionsFilter {
    PARENT("Relative", 1),
    CHILD("Relative", 2),
    SPOUSE("Relative", 3),
    SIBLING("Relative", 4),
    OWNER("Connection", 7),
    CEO("Connection", 8),
    COLLEAGUE("Connection", 9),
    EMPLOYEE("Connection", 10);

    OptionsFilter(String type, int val) {
        this.type = type;
        this.val = val;
    }

I renamed some methods (like: getList<String[]>(names) to getListOfValues(List<String> names)
(where the difficult part is remembering that 'name' stands for the name of an enum value)
And my main is now (not bothered by the tests)

public static void main(String... args) {
    String type = "Relative";
    List<Integer> externalList = new ArrayList<>(List.of(0, 3, 7, 8));
    List<Integer> filterSubset = OptionsFilter.getListOfValues(OptionsFilter.getListOfNames(type));
    externalList.retainAll(filterSubset);
    System.out.println(externalList);
}

[Kenji Watanabe]

@Junilu
As I wrote the testing of the value was just to be sure the code worked but it should be like your version.
I do think your solution is what I am searching for. Only I do not understand how the predicate gets set by getPredicate(subset) for each option. Could you explain how you intend to use that?

[Kenji Watanabe]

@Piet
Your solution works for the fixed configuration of these two subsets, Connections and Relatives. I was also looking for a way to add easily a new subset of values, like Acquintances or Clients f.e. with no further impact on the design.


By all means, thanks to both of you!

[Junilu Lacar]

Kenji Watanabe wrote:Only I do not understand how the predicate gets set by getPredicate(subset) for each option. Could you explain how you intend to use that?

There are several ways you can go about this and still retain type-safety. Let's start with the simple way first.

If the subsets are not going to be very volatile, then you could define them as constant lists:

private static final List<OptionsFilter> RELATIVES = List.of(PARENT, CHILD, SPOUSE, SIBLING);
private static final List<OptionsFilter> CONNECTIONS = List.of(OWNER, CEO, COLLEAGUE, EMPLOYEE);

private static final Map<String, List<OptionsFilter>> subsets = Map.of(
   "relatives", RELATIVES,
   "connections", CONNECTIONS);

public static Predicate<OptionsFilter> getPredicate(String subset) {
   String subsetKey = subset.trim().toLowerCase();

   // get the subset or default to everything; make it final so we can capture it in a closure
   final List<OptionsFilter> subset = subsets.getOrDefault(subsetKey, Arrays.asList(OptionsFilter.values()));

   // the predicate is a closure that "captures" the given subset
   return { o -> subset.contains(o) };
}

[Junilu Lacar]

Another way is to define your subsets themselves as enums and take a similar approach as that shown by Piet:

package mypackage;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

import static mypackage.FiltersDemo.Subset.CONNECTION;
import static mypackage.FiltersDemo.Subset.RELATIVE;
import static java.util.stream.Collectors.*;

public class FiltersDemo {

    // Just a container; don't instantiate this
    private FiltersDemo() {}
    
    public static enum Subset {
        RELATIVE, CONNECTION;
    }

    public static enum OptionFilter {
        PARENT(RELATIVE, "1"),
        CHILD(RELATIVE, "2"),
        SPOUSE(RELATIVE, "3"),
        SIBLING(RELATIVE, "4"),
        OWNER(CONNECTION, "7"),
        CEO(CONNECTION, "8"),
        COLLEAGUE(CONNECTION, "9"),
        EMPLOYEE(CONNECTION, "10");

        private final FiltersDemo.Subset subset;
        private final String code;

        private OptionFilter(FiltersDemo.Subset subset, String code) {
            this.subset = subset;
            this.code = code;
        }

        public FiltersDemo.Subset getSubset() {
            return this.subset;
        }

        public String getCode() {
            return this.code;
        }

        // stick with similar semantics as built-in values() method
        public static OptionFilter[] values(FiltersDemo.Subset subset) {
            List<OptionFilter> subList = Arrays.stream(values())
                    .filter(e -> e.subset == subset)
                    .collect(toList());
            OptionFilter[] results = new OptionFilter[subList.size()];
            IntStream.range(0, subList.size())
                    .forEach(i -> results[i] = subList.get(i));
            return results;
        }
    }
}

You can then do this:

// if subsetName is "relative"
OptionsFilter[] relatives = OptionsFilter.values(Subset.valueOf(subsetName.toUpperCase()));

// if subsetName is "connection"
OptionsFilter[] connections = OptionsFilter.values(Subset.valueOf(subsetName.toUpperCase()));

In contrast to what you had earlier, this code works primarily with enum values rather than strings.

[Kenji Watanabe]

I think I'll go for the first version because of the requirement to make up new subsets. Thank you for the elaboration.

[Junilu Lacar]

You can run the live demo here: https://repl.it/@jlacar/EnumSubsetDemo

[Junilu Lacar]

Kenji Watanabe wrote:I think I'll go for the first version because of the requirement to make up new subsets. Thank you for the elaboration.

Both ways require code changes if you're going to add new enum values. If you're just defining new subsets of the same set of enum values, then the first way I showed is a little bit more flexible because you can always inject the subsets you want to define through Spring, for example, without changing any code.

[Kenji Watanabe]

Hi Junilu, cool, works like a charm. But yes, defining new subsets of the same set of enum values, so the first way is preferred. Thanks again!

[Junilu Lacar]

One last thought.

In that getPredicate(String subsetName) method, I had this:
  // get the subset or default to everything; make it final so we can capture it in a closure   final List<OptionsFilter> subset = subsets.getOrDefault(subsetKey, Arrays.asList(OptionsFilter.values()));
The default of giving back all the enum values for an invalid subset name is one design choice. Depending on the semantics you want to create, it could also be more appropriate to return an empty list for an invalid subset name. It just depends on what makes sense in the most common usage scenario.