Adding elements of one generic container to another

Question

Hello,
I have the following problem. I have a class that can contain objects of various kinds, let's call it a Box. Since I'm implementing an algorithm that works the same no matter what's in the box, I thought I'd do something like this:
public class Box<E> extends Vector<E> {
    public void additionalMethod() { ... }
public interface BoxFactory {
    public Box<?> createBox();
public class IntegerBoxFactory implements BoxFactory {
    public Box<Integer> createBox() { ... }
public class RealBoxFactory implements BoxFactory {
    public Box<Double> createBox() { ... }
}etcetera. Then, the client class creates boxes using the factory without needing to know what is being created. However this turns out to be a problem since at some point I need to add the contents of one box to another, e.g.
public class Test {
    public void test() {
        BoxFactory factory = new RealBoxFactory();
        Example e = new Example( factory );     
public class Example {
    BoxFactory factory;
    public Example( BoxFactory f ) {
        factory = f;
        Box<?> b1 = f.createBox(),
                     b2 = f.createBox();
        mix( b1, b2 );
    public void mix( Box<?> b1, Box<?> b2 ) {
        b1.addAll( b2.subList( 1, 5 ) );
}This doesn't compile because clearly the contents of unknown type of one Box cannot be added to another, and neither does
    public void <E> mix( Box<E> b1, Box<E> b2 ) {
        b1.addAll( b2.subList( 1, 5 ) );
    }Since because b1 and b2 are both declared to be of Box<?>, the compiler can't know they contain the same type even if I do. So, I understand why this doesn't work, but I can't think of a way to make it work. Does anyone have any ideas?
Thanks
Matt

Answer 1

I'm sorry but I stubbornly keep thinking there must be another way to do it that doesn't oblige me to generify all the classes in the framework. And there is. Here's an ugly example of how, adapted from [one of Angelika Langer's FAQ entries|http://www.angelikalanger.com/GenericsFAQ/FAQSections/ProgrammingIdioms.html#FAQ207].
First, add to the container class a method that returns a type token that represents the container's element type so that we can retrieve the element type dynamically at run-time:
public abstract class Box<E> extends Vector<E> {
    public abstract Class<E> getElementType();
public class RealBox extends Box<Double> {
    public Class<Double> getElementType() { return Double.class; }
} Then, use a generic helper method to do the "mixing" (in this example):
public class Example {
    //adds a sublist of Box b2 to Box b1
    public void mix( Box<?> b1, Box<?> b2 ) {
        List<?> l = b2.subList( 0, 5 );
        for ( Object o : l )
            _add( b1, o );
    //adds Object o to Box b by retrieving the Box's run-time element type and then casting to it
    private <T> void _add( Box<T> b, Object o ) {
        b.add( b.getElementType().cast( o ) );
}This compiles and there are no unchecked warnings, and I don't need to generify the example class. Hurray. But this solution seems no better than the solution without generics. Also, it seems that Gilad Bracha's statement in the Generics tutorial
>
[generics] is designed to guarantee that if your entire application has been compiled without unchecked warnings using javac -source 1.5, it is type safe>
is not always true (but maybe this is old news), since the code above compiles without unchecked warnings using javac -source 1.6, but it is not type safe:
public class Example {
    public Example() {
        Box<?> b1 = new RealBox(),
               b2 = new IntegerBox();
        mix( b1, b2 ); //compiles fine but will cause a run-time error when trying to cast Integer to Double in method _add
}Anyway, if anybody knows of any other solutions other than generifying everything or employing this ugly solution, I'd be happy to hear it.