For any type selector

Question

This might be covered elsewhere in the forum but my searches have been fruitless.
Given:
public Object genKey(Class clazz) {
}and
public interface Keyed<K> {
  public void setKey(K key);
  public Class<K> keyClass();
}this is a valid use:
  Keyed<X> keyed = ...;
  Object key = genKey(keyed.keyClass());
  keyed.setKey(keyed.keyClass().cast(key));
...Now, say I have some framwork code that checks that an arbitrary object implements Keyed and assigns a key if it does:
if ( Keyed.class.isAssignableFrom( obj.getClass() ) {
  Keyed keyed = (Keyed)obj;
  Object key = genKey(keyed.keyClass());
  keyed.setKey( keyed.keyClass().cast(key));
...Of course, the call to setKey generates a warning. But there is enough information there for the compiler to determine that the call is type-safe.
What I seek is a way to declare the variable keyed with the semantics "for any type Y" as the generic selector. A wildcard doesn't work because it doesn't provide a handle to the selected type.
Is there some way to to express this meaning in Java 5 or am I stuck with the warning?
if ( Keyed.class.isAssignableFrom( obj.getClass() ) {
  Keyed<any Y> keyed = (Keyed)obj;
  Object key = genKey(keyed.keyClass());
  keyed.setKey( keyed.keyClass().cast(key));
}Tia,
-=greg

Answer 1

I omitted some explanation to keep it simple, but I probably made it less clear.
this is a valid use:
What do you mean by "valid use"? Do you mean it
"compiles"? Of course, it does compile, as cast()
takes any Object as parameter, regardless if the cast
will succeed.I understand this. By valid, I mean the it is type-safe from the compiler's
point of view. I know that an invalid cast will throw an exception at runtime
and that by using the cast call, I assume responsibility.
if ( Keyed.class.isAssignableFrom( obj.getClass()  )
Keyed keyed = (Keyed)obj;
Object key = genKey(keyed.keyClass());
keyed.setKey( keyed.keyClass().cast(key));
...Of course, the call to setKey generates a warning.
But there is enough information there for the
compiler to determine that the call is type-safe.No, it's not. You are using raw type Keyed here, so
there is no type-safety involved. The cast may
succeed or fail, who knows? Again, just talking about the compile-time safety interpretation here. Ignore
the potential runtime exceptions.
There is enough information here in the sense that any Class instance
returned from the keyClass() call is guaranteed to be compatible with the
parameter type of the setKey(..) call--according to the interface definition
alone. The interface implementation could, of course, return all kinds of
wrong things. But the issue I was trying to address in this post has only to do
with the compiler warning issued in the setKey(..) call.
You can use Keyed<T> keyed = (Keyed)
obj; so you actually see the origin of the
warning. Information on T only is available at
compile-time. There is no Keyed<T>.class, so you can
neither test its assignability nor cast to it. Hence,
the warning about erasure. The rest of your code
still remains the same, unsafe code, while the
compiler gets forced to accept it as type safe.I know this. I am simply trying determine if there is a way to, as a
compile-time benefit only, introduce a binding of the "for any" kind. It is a
useful semantic that I don't think is available in the language.
A first thing would be to parametrize genKey, e.g.:
public <T> T genKey(Class<T> clazz) throws
InstantiationException, IllegalAccessException {
return clazz.newInstance();
And, indeed, it is actually implemented in such a fashion--I provided the
version I did because it spells out the problem more clearly. The problem
is that in the framework code snippet ONLY, there is no way to express the
selector because, as you have pointed out, it cannot be determined.
So, the original question is the same--and I think the answer is probably
"no": can an arbitrary selector be introduced with the meaning "for any?"
Wildcarding is inches from being the right meaning but there is no selector
introduction.
Secondly, you will have to define a type to be used
in the context, so you can connect outcomes to a
@SuppressWarnings("unchecked")
Keyed<T> keyed = (Keyed) obj;
Right. Doing this is closest to what I was seeking but it is not a true
representation of the semantic (i.e. it still generates a warning).
So, what I'm hearing so far is, "no, there is not a syntactic construct that will
express a 'for any selector' concept other than to force it and accept the
resulting warning." That answer is fine with me, I just didn't want to miss out
on any better way.
-=greg