I still have to say I disagree with several of your points though. Especially when it comes to type checking and whether you get the warning at compile time or not.

The core issue here is when you work with type unsafe structures such as:


Map someMap = new HashMap();


This is the case for a HttpSession which I have used as example in my blog entry.

It does not matter if you cast any structure put into that map using my solution with a static cast-method, or using your adapter pattern. In both cases you will not detect any incorrect cast before runtime, and with the adapter you are simply moving the location where the cast exception will be thrown into the adapter.

Consider this case:


final Map someMap = new HashMap();
final List<Map> listOfMapsOfIntegers = newArrayList();
someMap.put("listOfMapsOfIntegers", listOfMapsOfIntegers);


Now, consider another part of you code trying to access this “list of maps of Integers”, but it is being cast to the incorrect type, like this:


final List<Map<String, Set>> myIncorrectlyCastMap = (List<Map<String, Set>>) someMap
.get("listOfMapsOfIntegers");


or this:


final List<Map<String, Set>> myIncorrectlyCastMap = cast(someMap
.get("listOfMapsOfIntegers"));


Either way, you will not receive an error until that code is actually executed, which only causes the cast-method to increase code readability, in my opinion.

Introducing the adapter pattern and having methods for accessing every single object that has been put into the map adds a significant amount of unnecessary code to the project.

It’s an interesting discussion though, and again thanks for taking your time to respond to my proposed solution

Jaran

Phonebook book = sessionAdapter.getPhonebook();

where Phonebook is an object (whose underlying behavior is a map of sets).

As for the cast, in some cases I’ve found it really useful to get loosely typed behavior in a strongly typed language, but you’re right, using that cast trick opens up too way many holes. For me, I created a whole lot of static functions such as Value.String(name) that force any arguments into the type OR return null (but never exceptions). Then there is a string called “name” in the system, or not (and if there is an integer, it is explicitly converted to a String because the code knows how to do that). Thus the code is loosely typed, but still very deterministic (and not going to blow up with strange exceptions when running).

Paul.