code: public Object readObjectFrom(Map row) throws PersistenceBrokerException
      {
          // allow to select a specific classdescriptor
          ClassDescriptor cld = selectClassDescriptor(row);
          return buildOrRefreshObject(row, cld, null);
      }
docs: materialize a single object, described by cld,
  from the first row of the ResultSet rs.
  There are two possible strategies:
  1. The persistent class defines a public constructor with arguments matching the persistent
  primitive attributes of the class. In this case we build an array args of arguments from rs
  and call Constructor.newInstance(args) to build an object.
  2. The persistent class does not provide such a constructor, but only a public default
  constructor. In this case we create an empty instance with Class.newInstance().
  This empty instance is then filled by calling Field::set(obj,getObject(matchingColumn))
  for each attribute.
  The second strategy needs n calls to Field::set() which are much more expensive
  than the filling of the args array in the first strategy.
  client applications should therefore define adequate constructors to benefit from
  performance gain of the first strategy.
  
  MBAIRD: The rowreader is told what type of object to materialize, so we have to trust
  it is asked for the right type. It is possible someone marked an extent in the repository,
  but not in java, or vice versa and this could cause problems in what is returned.
  
  we *have* to be able to materialize an object from a row that has a objConcreteClass, as we
  retrieve ALL rows belonging to that table. The objects using the rowReader will make sure they
  know what they are asking for, so we don't have to make sure a descriptor is assignable from the
  selectClassDescriptor. This allows us to map both inherited classes and unrelated classes to the
  same table.