public List<foo> getObjects() {
   List<foo> objects = null;
   try {
        Session session = HibernateUtil.currentSession();
        Transaction tx = session.beginTransaction();
        try {
            List returnList = session.find("from " + foo.class.getName());

            //This line is throwing a warning suggesting: "The expression of type List needs unchecked conversion to conform to List<foo>"
            objects = Collections.checkedList(returnList, foo.class);   
        } finally {
            tx.commit();
            HibernateUtil.closeSession();
        }
    } catch (HibernateException he) {}
    return objects;
}

  static final List<Terminal> EMPTY_LIST =
    Collections.unmodifiableList(new LinkedList<Terminal>());

.....

  public synchronized List<Terminal> getAllBeans(final int hints)
    throws DataException, BeanException, HibernateException
  {
    Logger log = Logger.getLogger( LOGGER_ID );
    log.entering( CNAME, "getAllBeans", hints );

    Session ses = allocWorkSession();
    try {
      Query qry = ses.getNamedQuery( "Terminal.all" );
      List<Terminal> res = toList(qry.list());
      log.exiting( CNAME, "getAllBeans", res );
      return res;
    }
    finally { freeWorkSession(); }
  }

....

                                // Utilities ---------------------------------

  /** Shallow type-cast copy. */
  public static List<Terminal> toList(final Collection<?> beans)
  {
    if ( beans == null )  return null;
    if ( beans.isEmpty())  return EMPTY_LIST;

    int cnt = beans.size();
    Terminal arr[] = new Terminal[cnt];
    arr = (Terminal[]) beans.toArray(arr);
    return Arrays.asList(arr);
  }

@SuppressWarnings(value={"unchecked"}) // although this isn't currently implemented, in the future it will supress
public List<foo> getObjects() {
   ...

return Collections.checkedList(objects, foo.class);

    try {
      arr = (AALanguage[]) beans.toArray(arr);
      return Arrays.asList(arr);
    }
    catch (ArrayStoreException e) {
      ClassCastException e2 = new ClassCastException("Failed to convert type to AALanguage!");
      e2.initCause(e);
      throw e2;
    }

  /** Shallow type-cast copy. */
  public static List<AALanguage> toList(final List<?> beans)
    throws ClassCastException
  {
    if ( beans == null )  return null;
    if ( beans.isEmpty())  return EMPTY_LIST;

    int cnt = beans.size();
    AALanguage arr[] = new AALanguage[cnt];
    try {
      arr = (AALanguage[]) beans.toArray(arr);
      return Arrays.asList(arr);
    }
    catch (ArrayStoreException e) {
      ClassCastException e2 = new ClassCastException("Failed to convert type to AALanguage!");
      e2.initCause(e);
      throw e2;
    }
  }

  @SuppressWarnings(value={"unchecked"})
  public synchronized List<AALanguage> getAllBeans(final int hints)
....
      List<AALanguage> res = (List<AALanguage>) qry.list();

/**
* <p>Generisised wrapper for criteria. Hopefully this will put all
* the unavoidable unchecked warnings into this one class.<p>
* @author malcolmm
*/
@SuppressWarnings("unchecked")
public class GenericCriteria<T> {
    Criteria crit;
   
    /** Creates a new instance of GenericCriteria
     * @param crit Criteria to wrap
     */
    public GenericCriteria(Criteria crit) {
        this.crit = crit;
    }
   
   
    /**
     * Create criteria from session
     * @param session The hibernate session
     * @param cls The class of the entities to be retrieved
     */
    public GenericCriteria(Session session, Class<T> cls) {
        this(session.createCriteria(cls));
    }
    /**
     * Add a restriction to the criteria
     * @param filter The criterion to apply
     */
    public void add(Criterion filter) {
        crit.add(filter);
    }
   
    /**
     * Impose an ordering on the criterion query.
     * @param order The order to impose
     */
    public void addOrder(Order order) {
        crit.addOrder(order);
    }
    /**
     * Get the results
     *
     */
    public java.util.List<T> list() throws HibernateException {
        return crit.list();
    }
   
    public T uniqueResult() {
        return (T)crit.uniqueResult();
    }
   
    public static <E> GenericCriteria<E> create(Session session, Class<E> targetClass) {
        return new GenericCriteria<E>(session,  targetClass);
    }
}

   public <K> GenericCriteria<K> createCriteria(String associationPath, Class<K> targetClass) {
      return new GenericCriteria(this.crit.createCriteria(associationPath));
   }