Comparable help

Question

Hi
I am trying to get rid of an "unchecked" warning, but I guess I have problems understanding how generics work.
I have an enum defined in the following way:
public enum Domain {
     INT(Number.class) {
          public Integer parse(Token token) {
               return Integer.decode(token.getValue());
     KEY(String.class) {
          public String parse(Token token) {
               return token.getValue();
     TEXT(String.class)  {
          public String parse(Token token) {
               return token.getValue();
     OCTET(String.class)  {
          public String parse(Token token) {
               return token.getValue();
     OCTETS(String.class)  {
          public String parse(Token token) {
               return token.getValue();
     DATE(java.sql.Timestamp.class) {
          public java.util.Date parse(Token token) {
               return new Timestamp(Long.parseLong(token.getValue()) * 1000);
     INT8(Number.class) {
          public Short parse(Token token) {
               return Short.decode(token.getValue());
     INT64(Number.class) {
          public Long parse(Token token) {
               return Long.decode(token.getValue());
     final Class sqlType;
     Domain(Class sqlType) {
          this.sqlType = sqlType;
     public Class getSqlType() {
          return sqlType;
     abstract public Comparable<? extends Comparable<?>> parse(Token token);
}When I want to use it, I get the value using
Comparable<Object> value = domain.parse(token)which gives me the unchecked error. Later I want to compare to values:
value1.compareTo(value2)Any declaration of "value" other than Comparable<Object> fails to compile the compareTo() call.
Any ideas how I need to declare "value" ?

Answer 1

Here's a version that compiles warning-free and allows you to compare arbitrary Domain instances mutually.
The catch: you can't leverage the added typesafety that the covariant return type provided. OTOH, this would only kick in if you used one of the enum constants directly. I guess you can't have it both ways...
public enum Domain {
     INT(Number.class) {
          public Comparable<Object> parse(Token token) {
               return wrap(Integer.decode(token.getValue()), Integer.class);
     KEY(String.class) {
          public Comparable<Object> parse(Token token) {
               return wrap(token.getValue(), String.class);
     final Class sqlType;
     Domain(Class sqlType) {
          this.sqlType = sqlType;
     public Class getSqlType() {
          return sqlType;
     abstract public Comparable<Object> parse(Token token);
     static <T extends Comparable<T>> Comparable<Object> wrap(final T value, final Class<T> cl) {
          return new Comparable<Object>() {
               public int compareTo(Object o) {
                    return value.compareTo(cl.cast(o));
}