this will involve alot of work. Not only will we have to change the parameter types and return types for all GWT services, but it means all GWT Impls will need to change to use the concrete types which would (and almost certainly will) means changing SLSB API to use concrete types OR we do unchecked casting which could cause problems in the future if we change SLSB implementations.

For example:

in TagGWTService we have this:

    Set<Tag> addTags(Set<Tag> tags) throws RuntimeException;

We'd have to change both parameter and return type to this:

    HashSet<Tag> addTags(HashSet<Tag> tags) throws RuntimeException;

This means we need to change TagGWTServiceImpl from:

    public Set<Tag> addTags(Set<Tag> tags) throws RuntimeException {
        try {
            return SerialUtility.prepare(tagManager.addTags(getSessionSubject(), tags), "TagService.addTags");
        } catch (Throwable t) {
            throw getExceptionToThrowToClient(t);
        }
    }

to something like:

    public HashSet<Tag> addTags(HashSet<Tag> tags) throws RuntimeException {
        try {
            HashSet<Tag> results = new HashSet<Tag>(tagManager.addTags(getSessionSubject(), tags)); // new collection that is explicitly of concrete type HashSet
            return SerialUtility.prepare(results, "TagService.addTags");
        } catch (Throwable t) {
            throw getExceptionToThrowToClient(t);
        }
    }

which requires a duplicate HashSet object to be created, just so we can have a concreate class, which is probably stupid. So we would alternatively have to do something like:


    public HashSet<Tag> addTags(HashSet<Tag> tags) throws RuntimeException {
        try {
            HashSet<Tag> results = (HashSet<Tag>) tagManager.addTags(getSessionSubject(), tags); // unchecked cast - what if addTags isn't really returning a HashSet?
            return SerialUtility.prepare(results, "TagService.addTags");
        } catch (Throwable t) {
            throw getExceptionToThrowToClient(t);
        }
    }

This just does a cast to the concrete type - but requires us to know the SLSB implementation details - that is, what is the actual concrete type that it is returning.

The other alternative is to change the SLSB API to explicitly return the concrete type, so TagManager would be something like "HashSet addTags(....)". The negative of this is it now forces changes to everyone calling that API, which may affect remote interfaces/clients/CLI scripts.