Mark said:
If that can't work, then I think you are going to have to refactor the
code and pass a class object in as a parameter when you create the class.
This whole reifiable type issue is starting to burn me up. I think Sun
should give us a Reifiable annotation that we can use to make the
compiler add some boilerplate for reifiable types.
Here's what I mean. There's a lot of boilerplate here that could be
just generated. The only thing I'm not sure of is how to handle Classes
where the Class object refers to a reifiable type. Maybe more maybe later.
I wrote this for my own edification, not because I think the OP needs
it. Are we at the point where there should be a standard pattern for
rolling your own reifiable type? Here's a simple example I have.
Please let me know what you think.
The pattern is:
1. Curse Sun for not giving us reifiable types.
2. Add a final Class variable for each parameterized type.
3. Add a constructor so that the class can be instatiated with just it's
types.
4. Modify existing constructors so that they set the correct types for
their parameters.
5. Add getters for each reifiable type to return the class. Name these
by adding the word "Class" to the end of the method name for the getters
for the corresponding values. For example, the getter to return the
class of getSomeValue() is getSomeValueClass().
6. Optionally add a convenience method to return the class of all
parameterized type. Name this method by adding the word "Classes" to the
end of the method name (which is the same as adding the word "Classes"
to the end of the constructor. This method should return a Class array
with the elements from 0 up corresponding to the order of the arguments
in the constructor left to right.
7. Don't forget to declare the number of reifiable types as a constant.
Well that's what I got so far. I'd really rather see this integrated
into reflection rather than having to do it by hand each time. If Sun
can overload a try-catch to automagically close Closeable objects, they
can gen some boilerplate for reifiable objects.
package reifiabletypes;
import java.math.BigDecimal;
/**
* Curse you, Sun!!
* Give us @Reifiable.
*/
public class Main {
/**
* @param args the command line arguments are ignored.
*/
public static void main(String[] args) {
// TODO code application logic here
SomePair<BigDecimal,BigDecimal> spbn =
new SomePair( BigDecimal.class, BigDecimal.class );
SomePair<Integer, Integer> spii =
new SomePair( Integer.class, Integer.class );
System.out.println("spbn first class: " + spbn.getFirstClass() );
System.out.println("spbn second class: " + spbn.getSecondClass() );
System.out.println("spii first class: " + spii.getFirstClass() );
System.out.println("spii second class: " + spii.getSecondClass() );
}
}
/**
* A sample, test reifiable type.
*/
class SomePair<FIRST, SECOND>
{
public final static int NUM_PARM_TYPES = 2;
private FIRST first;
private SECOND second;
private Class<FIRST> firstClass;
private Class<SECOND> secondClass;
public SomePair(Class<FIRST> firstClass,
Class<SECOND> secondClass)
{
this.firstClass = firstClass;
this.secondClass = secondClass;
}
public SomePair(FIRST first, SECOND second )
{
this.first = first;
this.second = second;
firstClass = (Class<FIRST>)first.getClass();
secondClass = (Class<SECOND>)second.getClass();
}
public FIRST getFirst() {
return first;
}
public SECOND getSecond() {
return second;
}
public Class<FIRST> getFirstClass() {
return firstClass;
}
public Class<SECOND> getSecondClass() {
return secondClass;
}
public Class [] getSomePairClasses( ) {
Class [] ca = new Class[NUM_PARM_TYPES];
ca[0] = firstClass;
ca[1] = secondClass;
return ca;
}
}
