import java.util.Properties;
import org.hibernate.LockOptions;
+import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
* @param newInstance
* new object as a transient instance
* @return new primary key for the created persistent object
+ * @see Session#save(Object)
*/
PK create(T newInstance);
*
* @param newInstance
* new object as a transient instance
+ * @see Session#saveOrUpdate(Object)
*/
public void saveOrUpdate(final T newInstance);
* @param id
* primary key of an object to read
* @return an object found by the given key
+ * @see Session#get(Class, Serializable)
*/
T get(PK id);
*
* @param transientObject
* transient instance of the object to refresh
+ * @see Session#refresh(Object)
*/
void refresh(T transientObject);
* transient instance of the object to load
* @param id
* object primary key
+ * @see Session#load(Object, Serializable)
*/
public void load(final T transientObject, final PK id);
* transient instance of the object to lock
* @param lockOptions
* lock options
+ * @see Session#refresh(Object, LockOptions)
*/
public void refresh(final T transientObject, final LockOptions lockOptions);
*
* @param persistentObject
* a persistent object to delete from the database
+ * @see Session#delete(Object)
*/
void delete(T persistentObject);
*/
public List<T> getFilteredList(final DetachedCriteria aDetachedCriteria);
+ /**
+ * Retrieve a list of DTO objects using the given criteria.
+ *
+ * @param <DTO>
+ * the class of returned DTOs
+ * @param aDetachedCriteria
+ * search criteria
+ * @return a list of DTO objects filtered according to the given criteria
+ */
+ public <DTO> List<DTO> getFilteredDTOList(
+ final DetachedCriteria aDetachedCriteria);
+
/**
* Retrieve a list of objects which were previously persisted to the database using the given criteria.
*
public List<T> getFilteredList(Properties andParams, Order... anOrder);
/**
- * Makes detached object persistent.
+ * Make a transient instance persistent. This operation cascades to <BR>
+ * associated instances if the association is mapped with cascade="persist".
*
* @param transientObject
* transient instance of the object to be made persistent
+ * @see Session#persist(Object)
*/
public void persist(T transientObject);
/**
- * Merge detached object with persistent data.
+ * Copy the state of the given object onto the persistent object with the <BR>
+ * same identifier. If there is no persistent instance currently associated<BR>
+ * with the session, it will be loaded. Return the persistent instance. If <BR>
+ * the given instance is unsaved, save a copy of and return it as a newly <BR>
+ * persistent instance. The given instance does not become associated with <BR>
+ * the session. This operation cascades to associated instances if the <BR>
+ * association is mapped with cascade="merge".
*
* @param transientObject
* transient instance of the object to be merged with persistent data
* @return merged persistent object
+ * @see Session#merge(Object)
*/
public T merge(T transientObject);
+ /**
+ * Remove this instance from the session cache. Changes to the instance will<BR>
+ * not be synchronized with the database. This operation cascades to <BR>
+ * associated instances if the association is mapped with cascade="evict".
+ *
+ * @param persistentObject
+ * the object to be removed from session cache
+ * @see Session#evict(Object)
+ */
+ public void evict(final T persistentObject);
+
/**
* Synchronize the session data with the database.
+ *
+ * @see Session#flush()
*/
public void flush();
}