Doing without Generics - ideas??

Question

HI everyone,
I (unfortunately) can not use Generics in the current project I'm working on but am facing a problem that I feel would be best solved by Generics. In fact, the existing C++ versions works a charm using the parameterized approach.
Problem: C++ Objects are created from XML specifications of classes. Want to now create from these specs, Java objects.
small example,
<class name="Foo">
<field name="SomeVar">
<type = "list">
<list-subtype type="string">
</list>
</field>
</class>
This would create Foo.{cpp,h} with
std::list<std::string> SomeVar;
The other side of the problem is turning the object back into
the XML specification.
I have been thinking about how best to design for this problem, but keep
getting stuck on aspects such as lists of maps. IN c++ you know the element types in the list (or can work it out), but in Java it's a different story.
Should I implement type-safe classes such as StringList, IntegerList
etc.. which restrict access to the LinkedList they each hold? Or should I just rely on reflection and subsequently call (possible) hundreds of different methods. A speed is a major consideration, the fewer calls the better.
I would appreciate any input you have on this point.
Cheers

Answer 1

i dont't fully understand the problem. how would these generated classes be used, by human programmers or by generated code? supposing human programmers, is the contents of collections your only problem? if this is so and you want to guarantee the content type, there's a simple solution. write wrappers for the collection interfaces you use that type-check elements, keys and values on input to the backing collection. make the constructor take the backing collection and the element type(s) (Class object(s)) as arguments, and every time an element, key or value is to be inserted into the collection, validate them using something like:
if (!type.isInstance(obj))
     if (obj == null) throw new NullPointerException();
     else throw new ClassCastException();
or:
if (!type.isInstance(obj) && obj != null) throw new ClassCastException();
if you want to accept nulls. of course, when you get objects from the collection you'll have to cast, but the collection contents will be sort of type-safe.
as i said i dont't fully understand the problem, and don't think this will help much, but if it does, let me give you some pointers. safe wrapper implementations may be a bit trickier than you think, specially the MAP wrapper which involves wrapping several views, iterators and MAP.ENTRYs, and has to witstand subtle attacks like evil equals() implementations. use the source code for the Collections.unmodifiableXxx() wrappers as a starting point. these wrappers stop all mods, so you'll just have to put the tests in and you are done. then you can generate code like:
List someVar = TypedCollections.typedList(String.class, new ArrayList());
alternatively you may use factories. using factories, if you later find that typed LinkedLists are used a lot and the wrapping impacts performance, you could optimize by making the factory return a specilized typed implementation for that case (based on/extending LinkedList), but i really don't think it would be worth the effort.
you may later need type info from the collection, so maybe you want say interface TypedCollection (extending Collection) and TypedMap (extending Map) implemented by these wrappers. the interfaces have getters to return element, key or value type info. but note that if you use other wappers (like unmodifiable) you'll lose the chance to query this info (unless you extend those wrappers yourself, of course).
i hope some of this stuff helps, but it probably won't. so what? cheers!!