Compiletime validation of enum parameters

Question

There is a constructor with three parameters of type enum:

public SomeClass(EnumType1 enum1,EnumType2 enum2, EnumType3 enum3)
{...}

The three parameters of type enum are not allowd to be combined with all possible values:

Example:

EnumType1.VALUE_ONE, EnumType2.VALUE_SIX, EnumType3.VALUE_TWENTY is a valid combination.

But the following combination is not valid:

EnumType1.VALUE_TWO, EnumType2.VALUE_SIX, EnumType3.VALUE_FIFTEEN

Each of the EnumTypes knows with which values it is allowed to be combined:

EnumType1 and the two others implement a isAllowedWith() method to check that as follows:

public enum EnumType1 {

VALUE_ONE,VALUE_TWO,...;

    public boolean isAllowedWith(final EnumType2 type) {
    switch (this) {
        case VALUE_ONE:
            return type.equals(Type.VALUE_THREE);
        case VALUE_TWO:
            return true;
        case VALUE_THREE:
            return type.equals(Type.VALUE_EIGHT);
        ...
    }
}

I need to run that check at compile time because it is of extreme importance in my project that the combinations are ALWAYS correct at runtime.

I wonder if there is a possibility to run that check with user defined annotations?

Every idea is appreciated :)

Answer 1

The posts above don't bring a solution for compile-time check, here's mine:

Why not use concept of nested Enum.

You would have EnumType1 containing its own values + a nested EnumType2 and this one a nested EnumType3.

You could organize the whole with your useful combination. You could end up with 3 classes (EnumType1,2 and 3) and each one of each concerned value containing the others with the allowed associated values.

And your call would look like that (with assuming you want EnumType1.VALUE_ONE associated with EnumType2.VALUE_FIFTEEN) :

EnumType1.VALUE_ONE.VALUE_FIFTEEN  //second value corresponding to EnumType2

Thus, you could have also: EnumType3.VALUE_SIX.VALUE_ONE (where SIX is known by type3 and ONE by type1).

Your call would be change to something like:

public SomeClass(EnumType1 enumType)

=> sample:

SomeClass(EnumType1.VALUE_ONE.VALUE_SIX.VALUE_TWENTY) //being a valid combination as said

To better clarify it, check at this post: Using nested enum types in Java

Answer 2

So the simplest way to do this is to 1) Define the documentation to explain valid combinations and
2) add the checks in the constructor

If a constructor throws an Exception than that is the responsibility of the invoker. Basically you would do something like this:

public MyClass(enum foo, enum bar, enum baz)  
{  
    if(!validateCombination(foo,bar,baz))
    {  
        throw new IllegalStateException("Contract violated");
    }  
} 


private boolean validateCombination(enum foo, enum bar, enum baz)  
{  
    //validation logic
} 

Now this part is absolutely critical. Mark the class a final, it is possible that a partially constructed object can be recovered and abused to break your application. With a class marked as final a malicious program cannot extend the partially constructed object and wreak havoc.

Answer 3

One alternative idea is to write some automated tests to catch this, and hook them into your build process as a compulsory step before packaging/deploying your app.

If you think about what you're trying to catch here, it's code which is legal but wrong. While you could catch that during the compilation phase, this is exactly what tests are meant for.

This would fit your requirement of not being able to build any code with an illegal combination, because the build would still fail. And arguably it would be easier for other developers to understand than writing your own annotation processor...

Answer 4

The only way I know is to work with annotations.

Here is what I do I mean. Now your constructor accepts 3 parameters:

public SomeClass(EnumType1 enum1,EnumType2 enum2, EnumType3 enum3){}

so you are calling it as following:

SomeClass obj = new SomeClass(EnumTupe1.VALUE1, EnumTupe2.VALUE2, EnumTupe1.VALUE3)

Change the constructor to be private. Create public constructor that accept 1 parameter of any type you want. It may be just a fake parameter.

public SomeClass(Placeholder p)

Now you have to require to call this constructor while each argument is annotated with special annotation. Let's call it TypeAnnotation:

SomeClass obj = new SomeClass(TypeAnnotation(
    type1=EnumType1.VALUE1, 
    type2=EnumTupe2.VALUE2,
    type3=EnumTupe1.VALUE3)
    p3);

The call is more verbose but this is what we have to pay for compile time validation.

Now, how to define the annotation?

@Documented @Retention({RetentionPolicy.RUNTIME, RetentionPolicy.SOURCE}) @Target(PARAMETER) @interface TypeAnnotation { EnumType1 type1(); EnumType2 type3(); EnumType3 type3(); }

Please pay attention that target is PARAMETER and retention values are RUNTIME and SOURCE.

RUNTIME allows reading this annotation at runtime, while SOURCE allows creating annotation processor that can validate the parameters at runtime.

Now the public constructor will call the 3-parameters private construcor:

public SomeClass(Placeholder p) { this(readAnnotation(EnumType1.class), readAnnotation(EnumType2.class), readAnnotation(EnumType3.class), ) }

I am not implementing readAnnotation() here: it should be static method that takes stack trace, goes 3 elements back (to caller of the public costructor) and parses annotation TypeAnnotation.

Now is the most interesting part. You have to implement annotation processor. Take a look here for instructions and here for an example of annotation processor.

You will have to add usage of this annotation processor to your build script and (optionally) to your IDE. In this case you will get real compilation error when your compatibility rules are violated.

I believe that this solution looks too complicated but if you really need this you can do this. It may take a day or so. Good luck.

Answer 5

Well, I am not aware of a compile time check but I do not think it is possible because how can the compiler know which value will be passed to the constructor (In case the value of your enum variable is calculated in runtime (e.g. by an If clause) ? This can only be validated on runtime by using a validator method as you implemented for the enum types.

Example :

If in your code you have something like this :

EnumType1 enumVal;

if (<some condition>) {
  enumVal = EnumType2.VALUE_SIX;
} else {
  enumVal = EnumType2.VALUE_ONE;
}

There is no way the compiler can know which of the values will be assigned to enumVal so it won't be able to verify what is passed to the constructor until the if block is evaluated (which can be done only in runtime)