Java generics variable value

Question

At the moment I am using the following code to do some filtering in jpa:

if (value.getClass() == Integer.class) {
   return cb.greaterThan(root.<Integer>get(field), (Integer) value);
} else if (value.getClass() == Long.class) {
   return cb.greaterThan(root.<Long>get(field), (Long) value);
} else if (value.getClass() == Float.class) {
   return cb.greaterThan(root.<Float>get(field), (Float) value);
} else if (value.getClass() == Date.class) {
   return cb.greaterThan(root.<Date>get(field), (Date) value);
}

How can i reduce this block to one line like that?

return cb.greaterThan(root.<value.getClass()>get(field), value);

So i need to replace the T value in < T > with my class type. Sadly i am not that good in java generics. Does anybody has an idea? Is it even possible?

root is of the following type: http://docs.oracle.com/javaee/6/api/javax/persistence/criteria/Path.html#get%28java.lang.String%29

edit: here is the full class i want to write:

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

public class FilterExpression {

    public static final Integer BEGINS_WITH = 0;
    public static final Integer ENDS_WITH = 1;
    public static final Integer CONTAINS = 2;
    public static final Integer EQUAL = 3;
    public static final Integer NOT_EQUAL = 4;
    public static final Integer GREATER_THAN = 5;
    public static final Integer GREATER_EQUAL_THAN = 6;
    public static final Integer LESS_THAN = 7;
    public static final Integer LESS_EQUAL_THAN = 8;
    private static final Map<String, Integer> OPERATOR_MAPPING;

    static {
        Map<String, Integer> temp = new HashMap<>();
        temp.put("bw", BEGINS_WITH);
        temp.put("ew", ENDS_WITH);
        temp.put("ct", CONTAINS);
        temp.put("eq", EQUAL);
        temp.put("nq", NOT_EQUAL);
        temp.put("gt", GREATER_THAN);
        temp.put("gq", GREATER_EQUAL_THAN);
        temp.put("lt", LESS_THAN);
        temp.put("lq", LESS_EQUAL_THAN);
        OPERATOR_MAPPING = Collections.unmodifiableMap(temp);
    }

    private String field;
    private Integer operator;
    private Object value;

    public FilterExpression(String field, String operator, String value, Class c) {
        this.field = field;
        setOperator(operator);
        setValue(value, c);
    }

    public Boolean validate() {
        if (StringUtils.isEmpty(field) || operator == null || value == null) {
            return false;
        }
        Class c = value.getClass();

        if (c == String.class) {
            return operator >= BEGINS_WITH && operator <= NOT_EQUAL;
        } else if (c == Integer.class || c == Float.class || c == Double.class) {
            return (EQUAL >= EQUAL && operator <= LESS_EQUAL_THAN);
        } else if (c == Boolean.class) {
            return operator == EQUAL || operator == NOT_EQUAL;
        } else if (c == Identification.Type.class) {
            return operator == EQUAL || operator == NOT_EQUAL;
        }
        return false;
    }

    public String getField() {
        return field;
    }

    public void setField(String field) {
        this.field = field;
    }

    public Integer getOperator() {
        return operator;
    }

    public void setOperator(String operator) {
        this.operator = OPERATOR_MAPPING.get(operator.toLowerCase());
    }

    public Object getValue() {
        return value;
    }

    public void setValue(String s, Class c) {
        try {
            if (Boolean.class == c) {
                this.value = validateBoolean(s);
            } else if (Integer.class == c) {
                this.value = Integer.parseInt(s);
            } else if (Float.class == c) {
                this.value = Float.parseFloat(s);
            } else if (Identification.Type.class == c) {
                this.value = Identification.Type.parse(Integer.parseInt(s));
            } else {
                this.value = s;
            }
        } catch (NumberFormatException ex) {
            this.value = null;
        }
    }

    public <R> Predicate toPredicate(CriteriaBuilder cb, Root<R> root) {
        if (Objects.equals(operator, FilterExpression.EQUAL)) {
            return cb.equal(root.get(field), value);
        } else if (Objects.equals(operator, FilterExpression.NOT_EQUAL)) {
            return cb.notEqual(root.get(field), value);
        } else if (Objects.equals(operator, FilterExpression.CONTAINS)) {
            return cb.like(root.<String>get(field), "%" + value + "%");
        } else if (Objects.equals(operator, FilterExpression.ENDS_WITH)) {
            return cb.like(root.<String>get(field), "%" + value);
        } else if (Objects.equals(operator, FilterExpression.BEGINS_WITH)) {
            return cb.like(root.<String>get(field), value + "%");
        } else if (Objects.equals(operator, FilterExpression.GREATER_THAN)) {
            if (value.getClass() == Integer.class) {
                return cb.greaterThan(root.<Integer>get(field), (Integer) value);
            } else if (value.getClass() == Float.class) {
                return cb.greaterThan(root.<Float>get(field), (Float) value);
            } else if (value.getClass() == Date.class) {
                return cb.greaterThan(root.<Date>get(field), (Date) value);
            }
        } else if (Objects.equals(operator, FilterExpression.GREATER_EQUAL_THAN)) {
            if (value.getClass() == Integer.class) {
                return cb.greaterThanOrEqualTo(root.<Integer>get(field), (Integer) value);
            } else if (value.getClass() == Float.class) {
                return cb.greaterThanOrEqualTo(root.<Float>get(field), (Float) value);
            } else if (value.getClass() == Date.class) {
                return cb.greaterThanOrEqualTo(root.<Date>get(field), (Date) value);
            }
        } else if (Objects.equals(operator, FilterExpression.LESS_THAN)) {
            if (value.getClass() == Integer.class) {
                return cb.lessThan(root.<Integer>get(field), (Integer) value);
            } else if (value.getClass() == Float.class) {
                return cb.lessThan(root.<Float>get(field), (Float) value);
            } else if (value.getClass() == Date.class) {
                return cb.lessThan(root.<Date>get(field), (Date) value);
            }
        } else if (Objects.equals(operator, FilterExpression.LESS_EQUAL_THAN)) {
            if (value.getClass() == Integer.class) {
                return cb.lessThanOrEqualTo(root.<Integer>get(field), (Integer) value);
            } else if (value.getClass() == Float.class) {
                return cb.lessThanOrEqualTo(root.<Float>get(field), (Float) value);
            } else if (value.getClass() == Date.class) {
                return cb.lessThanOrEqualTo(root.<Date>get(field), (Date) value);
            }
        }
        return null;
    }

What type is `root`? How is the `get()` method defined? What is `cb`? — RealSkeptic, Aug 17 '16 at 14:59
Note that the result of `root.get(field)` is no different from `root.get(field)`, since that type isn't available at runtime; the only valid safe value that can be returned from the method is `null`. — Andy Turner, Aug 17 '16 at 15:01
Depending on how `root` and `value` are defined, `cb.greaterThan(root.get(field), value);` can be enough. The only constraint that I can see in the javadoc on `T` is `>` — Arnaud Denoyelle, Aug 17 '16 at 15:01
@RealSkeptic here is the description: http://docs.oracle.com/javaee/7/api/javax/persistence/criteria/CriteriaBuilder.html#greaterThan-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression- — perotom, Aug 17 '16 at 15:07
@NicolasFilotto its from javax.persistence.criteria.Root. http://docs.oracle.com/javaee/6/api/javax/persistence/criteria/Root.html — perotom, Aug 17 '16 at 15:11
Have you tried `cb.greaterThan(root.get(field),(Comparable>)value)`? — RealSkeptic, Aug 17 '16 at 15:14
To some extend you may use the Java SE class [Number](https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html) with its conversion functions like `toLong`. — Joop Eggen, Aug 17 '16 at 15:19
AFAIK, it's not possible to determine the type of a generic at runtime. Generic type is compile time Java process. (https://docs.oracle.com/javase/tutorial/java/generics/erasure.html) You should read the full documentation about this. — Mickael, Aug 17 '16 at 15:20
@MickaëlB the answer from Codebender is not bad but i don´t know how to construct the generic class with a variable type. So you are saying that´s not possible? — perotom, Aug 17 '16 at 15:23
@user2630406 I already had this problem before and I had no choice to use a solution like Codebender proprosed. — Mickael, Aug 17 '16 at 15:28

score 3 · Answer 1 · answered Aug 17 '16 at 15:13

3

I guess you could make the whole class generic.

public class FilterExpression<T extends Comparable<T>> {
    //Make value to be type T instead of Object.
    T value;

    // And you could easily do,
    ...
    return cb.greaterThan(root.<T>get(field), value);
}

answered Aug 17 '16 at 15:13

Codebender

14,221
7
48
85

i also thought about that but how do you set the type of the generic class in the setValue method? – perotom Aug 17 '16 at 15:16
This is the *start* of what needs to happen...there are some logistics issues in why the logic for different classes all need to live in this one. – Makoto Aug 17 '16 at 15:17
Ok but how can i construct this generic class with an variable type? for example currently i determine the type from a Map. – perotom Aug 17 '16 at 15:20
@user2630406 You can't determine a class from a generic type. You need to pass the class as a parameter to the method who need it. Please see [this post](http://stackoverflow.com/questions/182636/how-to-determine-the-class-of-a-generic-type) – Charles Follet Aug 17 '16 at 15:23

Nicolas Filotto · Answer 2 · 2016-08-17T15:40:55.817

2

As the code of your method is complex since everything is mixed, if you don't intend to refactor your method for me the simplest solution by far is relying on raw types as next:

return cb.greaterThan(root.<Comparable>get(field), (Comparable) value);

edited Aug 17 '16 at 15:40

answered Aug 17 '16 at 15:02

Nicolas Filotto

43,537
11
94
122

1

@RealSkeptic I agree that it is not an ideal solution but regarding the code of the OP's method where everything is mixed it would be the easiest one by far unless he refactors his code. If you have a simplest solution, please share – Nicolas Filotto Aug 17 '16 at 15:34

score 0 · Accepted Answer · answered Aug 17 '16 at 15:44

With the two answers from codebender and nicolas filotto i was able to do it. I had to remove the setValue method to put it outside the class. So here is the complete class:

public class FilterExpression<T extends Comparable<T>> {

    public static final Integer BEGINS_WITH = 0;
    public static final Integer ENDS_WITH = 1;
    public static final Integer CONTAINS = 2;
    public static final Integer EQUAL = 3;
    public static final Integer NOT_EQUAL = 4;
    public static final Integer GREATER_THAN = 5;
    public static final Integer GREATER_EQUAL_THAN = 6;
    public static final Integer LESS_THAN = 7;
    public static final Integer LESS_EQUAL_THAN = 8;
    private static final Map<String, Integer> OPERATOR_MAPPING;

    static {
        Map<String, Integer> temp = new HashMap<>();
        temp.put("bw", BEGINS_WITH);
        temp.put("ew", ENDS_WITH);
        temp.put("ct", CONTAINS);
        temp.put("eq", EQUAL);
        temp.put("nq", NOT_EQUAL);
        temp.put("gt", GREATER_THAN);
        temp.put("gq", GREATER_EQUAL_THAN);
        temp.put("lt", LESS_THAN);
        temp.put("lq", LESS_EQUAL_THAN);
        OPERATOR_MAPPING = Collections.unmodifiableMap(temp);
    }

    private String field;
    private Integer operator;
    private T value;

    public FilterExpression(String field, String operator, T value) {
        this.field = field;
        setOperator(operator);
        this.value = value;
    }

    public Boolean validate() {
        if (StringUtils.isEmpty(field) || operator == null || value == null) {
            return false;
        }
        Class c = value.getClass();

        if (c == String.class) {
            return operator >= BEGINS_WITH && operator <= NOT_EQUAL;
        } else if (c == Integer.class || c == Float.class || c == Double.class || c == Date.class) {
            return (EQUAL >= EQUAL && operator <= LESS_EQUAL_THAN);
        } else if (c == Boolean.class) {
            return operator == EQUAL || operator == NOT_EQUAL;
        } else if (c == Identification.Type.class) {
            return operator == EQUAL || operator == NOT_EQUAL;
        }
        return false;
    }

    public String getField() {
        return field;
    }

    public void setField(String field) {
        this.field = field;
    }

    public Integer getOperator() {
        return operator;
    }

    public void setOperator(String operator) {
        this.operator = OPERATOR_MAPPING.get(operator.toLowerCase());
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public <R> Predicate toPredicate(CriteriaBuilder cb, Root<R> root) {
        if (Objects.equals(operator, FilterExpression.EQUAL)) {
            return cb.equal(root.<T>get(field), value);
        } else if (Objects.equals(operator, FilterExpression.NOT_EQUAL)) {
            return cb.notEqual(root.<T>get(field), value);
        } else if (Objects.equals(operator, FilterExpression.CONTAINS)) {
            return cb.like(root.<String>get(field), "%" + value + "%");
        } else if (Objects.equals(operator, FilterExpression.ENDS_WITH)) {
            return cb.like(root.<String>get(field), "%" + value);
        } else if (Objects.equals(operator, FilterExpression.BEGINS_WITH)) {
            return cb.like(root.<String>get(field), value + "%");
        } else if (Objects.equals(operator, FilterExpression.GREATER_THAN)) {
            return cb.greaterThan(root.<T>get(field), (T) value);
        } else if (Objects.equals(operator, FilterExpression.GREATER_EQUAL_THAN)) {
            return cb.greaterThanOrEqualTo(root.<T>get(field), (T) value);
        } else if (Objects.equals(operator, FilterExpression.LESS_THAN)) {
            return cb.lessThan(root.<T>get(field), (T) value);
        } else if (Objects.equals(operator, FilterExpression.LESS_EQUAL_THAN)) {
            return cb.lessThanOrEqualTo(root.<T>get(field), (T) value);
        } 
        return null;
    }

}

Java generics variable value

3 Answers3