Chained call pattern with inheritance, polymorphism and generics...

I'm trying to create a chainable call. so that I can do something like
myBuilder.something(createSomething()).something(createAnotherSomething()).other(createAnOther());

This isn't so hard if myBuilder is a concrete type with something()
and other() implemented in that concrete type. However, I'd like to
be able to have that hard work done in a base class. Basically, I
know that the something() is always going to return a reference to
"this", I just don't know the type of "this" beforehand. The only way
I could see to cleanly handle this, is to make a generic abstract
getThis() method that has to be implemented in all the concrete types.

public abstract class BaseBuilder<T extends BaseBuilder<T>> {
   Set<Something<T>> common = new HashSet<Something<T>>();
   public T something(Something<T> something) {
       common.add(something);
       return getThis(); // this;
   }

   protected abstract T getThis();
}

public BobsBuilder extends BaseBuilder<BobsBuilder> {

   BobsBuilder getThis() {
      return this;
   }
}

This gets even more complicated if I have several levels of
inheritance, including some sub-classes of already concrete types.

Anyone have a suggestion for a more elegant solution?