JFox Service-Oriented Application Framework

Clover coverage report - JFox Service-Oriented Application Framework - 1.0-RC1

Coverage timestamp: 星期五八月 19 2005 13:21:55 CST

FRAMES NO FRAMES

file stats:	LOC:	481		Methods:	0
	NCLOC:	69		Classes:	1

30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover

Source file

Conditionals

Statements

Methods

TOTAL

HibernateService.java

 /**
  * @(#)HibernateService.java
  * 
  * JFoxSOAF, Service-Oriented Application Framework
  * 
  * Copyright(c) JFoxSOAF Team
  * 
  * Licensed under the GNU LGPL, Version 2.1 (the "License"); 
  * you may not use this file except in compliance with the License. 
  * You may obtain a copy of the License at  
  * 
  * http://www.gnu.org/copyleft/lesser.html
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, 
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  * See the License for the specific language governing permissions and 
  * limitations under the License. 
  * 
  * For more information, please visit:
  * http://www.jfox.cn/confluence/display/JFoxSOAF/Home
  * http://www.huihoo.org/jfox/jfoxsoaf
  */
 
 package org.huihoo.jfox.soaf.services.persistence;
 
 import java.io.Serializable;
 import java.util.Iterator;
 import java.util.List;
 
 import net.sf.hibernate.HibernateException;
 import net.sf.hibernate.LockMode;
 import net.sf.hibernate.Session;
 import net.sf.hibernate.SessionFactory;
 import net.sf.hibernate.cfg.Configuration;
 import net.sf.hibernate.type.Type;
 
 import org.huihoo.jfox.soaf.exception.DAOException;
 
 /**
  * <p>
  * Hibernate persistence service, Wrapper service for hibernate.
  * </p>
  * 
  * @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
  * @version $Revision: 1.5 $ $Date: 2005/05/22 06:50:29 $
  * @version Revision: 1.0
  */
 
 public interface HibernateService {
 
     /**
      * Create database connection and open a Session on it.
      * 
      * @return a Hibernate Session object
      */
     public Session openSession() throws HibernateException;
 
     /**
      * Return hibernate configuration.
      * 
      * @return a Hibernate Configuration object
      */
     public Configuration getConfiguration() throws HibernateException;
 
     /**
      * Create SessionFactory.
      * 
      * @return a Hibernate SessionFactory object
      */
     public SessionFactory getSessionFactory() throws HibernateException;
 
     /**
      * commit transaction currently underway, and start new one ( as side effect
      * hibernate session will be flushed )
      */
     public void commit() throws HibernateException;
 
     /**
      * rollback active transaction if any was started. transaction will be reset
      * 
      * @throws HibernateException if transaction can not be rolled back
      */
     public void rollback() throws HibernateException;
 
     /**
      * normal session close. commit transaction is any
      */
     public void closeSession() throws HibernateException;
 
     /**
      * reset and clean up everything. shall be used is something went wrong (
      * for example you received hibernate exception )
      */
     public void reset();
     
     /**
      * Check if this instance is associated with this Session
      * 
      * @param object
      *            an instance of a persistent class
      * @return true if the given instance is associated with this Session
      * @throws HibernateException
      * @throws DAOException
      */
     public boolean contains(Object object) throws HibernateException,
             DAOException;
 
     /**
      * Remove a persistent instance from the datastore.
      * 
      * @param object
      * @throws HibernateException
      */
     public void delete(Object object) throws HibernateException, DAOException;
 
     /**
      * Remove a persistent instance from the datastore with lock mode.
      * 
      * @param object
      * @param lockMode
      * @throws HibernateException
      */
     public void delete(Object object, LockMode lockMode)
             throws HibernateException, DAOException;
 
     /**
      * Delete all objects returned by the query. Return the number of objects
      * deleted.
      * 
      * @param query
      * @return the number of instances deleted
      * @throws HibernateException
      * @throws DAOException
      */
     public int delete(String query) throws HibernateException, DAOException;
 
     /**
      * Delete all objects returned by the query. Return the number of objects
      * deleted.
      * 
      * @param query
      * @return the number of instances deleted
      * @throws HibernateException
      * @throws DAOException
      */
     public int delete(String query, Object value, Type type)
             throws HibernateException, DAOException;
 
     /**
      * Delete all objects returned by the query. Return the number of objects
      * deleted.
      * 
      * @param query
      * @return the number of instances deleted
      * @throws HibernateException
      * @throws DAOException
      */
     public int delete(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException;
 
     /**
      * Remove this instance from the session cache. Changes to the instance will
      * not be synchronized with the database. This operation cascades to
      * associated instances if the association is mapped with cascade="all" or
      * cascade="all-delete-orphan".
      * 
      * @param object
      *            object - a persistent instance
      * @throws HibernateException
      * @throws DAOException
      */
     public void evict(Object object) throws HibernateException, DAOException;
 
     /**
      * Execute a query.
      * 
      * @param query
      *            a query expressed in Hibernate's query language
      * @return a distinct list of instances (or arrays of instances)
      * @throws HibernateException
      * @throws DAOException
      */
     public List find(String query) throws HibernateException, DAOException;
     /**
      * Execute a query with bind parameters. Bind a value to a "?" parameter in
      * the query string.
      * 
      * @param query
      * @param value
      * @param type
      * @return a distinct list of instances (or arrays of instances)
      * @throws HibernateException
      * @throws DAOException
      */
     public List find(String query, Object value, Type type)
             throws HibernateException, DAOException;
 
     /**
      * Execute a query with bind parameters. Binding an array of values to "?"
      * parameters in the query string.
      * 
      * @param query
      * @param values
      * @param types
      * @return a distinct list of instances
      * @throws HibernateException
      * @throws DAOException
      */
     public List find(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException;
 
     /**
      * Return the persistent instance of the given entity class with the given
      * identifier, or null if there is no such persistent instance.
      * 
      * @param clazz
      * @param id
      * @return a persistent instance or null
      * @throws HibernateException
      * @throws DAOException
      */
     public Object get(Class clazz, final Serializable id) throws HibernateException,
             DAOException;
     /**
      * Return the persistent instance of the given entity class with the given
      * identifier, or null if there is no such persistent instance. Obtain the
      * specified lock mode if the instance exists.
      * 
      * @param clazz
      * @param id
      * @param lockMode
      * @return a persistent instance or null
      * @throws HibernateException
      * @throws DAOException
      */
     public Object get(Class clazz, final Serializable id, LockMode lockMode)
             throws HibernateException, DAOException;
 
     /**
      * Execute a query and return the results in an iterator. If the query has
      * multiple return values, values will be returned in an array of type
      * Object[]. Entities returned as results are initialized on demand. The
      * first SQL query returns identifiers only. So iterate() is usually a less
      * efficient way to retrieve objects than find().
      * 
      * @param query
      * @return an iterator
      * @throws HibernateException
      * @throws DAOException
      */
     public Iterator iterate(String query) throws HibernateException,
             DAOException;
 
     /**
      * Execute a query and return the results in an iterator. Write the given
      * value to "?" in the query string. If the query has multiple return
      * values, values will be returned in an array of type Object[]. Entities
      * returned as results are initialized on demand. The first SQL query
      * returns identifiers only. So iterate() is usually a less efficient way to
      * retrieve objects than find().
      * 
      * @param query -
      *            the query string
      * @param value -
      *            a value to be witten to a "?" placeholder in the query string
      * @param type -
      *            the hibernate type of value
      * @return an iterator
      * @throws HibernateException
      * @throws DAOException
      */
     public Iterator iterate(String query, Object value, Type type)
             throws HibernateException, DAOException;
 
     /**
      * Execute a query and return the results in an iterator. Write the given
      * values to "?" in the query string. If the query has multiple return
      * values, values will be returned in an array of type Object[]. Entities
      * returned as results are initialized on demand. The first SQL query
      * returns identifiers only. So iterate() is usually a less efficient way to
      * retrieve objects than find().
      * 
      * @param query
      * @param values
      * @param types
      * @return
      * @throws HibernateException
      * @throws DAOException
      */
     public Iterator iterate(String query, Object[] values, Type[] types)
             throws HibernateException, DAOException;
 
     /**
      * Return the persistent instance of the given entity class with the given
      * identifier, assuming that the instance exists. You should not use this
      * method to determine if an instance exists (use find() instead). Use this
      * only to retrieve an instance that you assume exists, where non-existence
      * would be an actual error.
      * 
      * @param clazz
      * @param id
      * @return the persistent instance or proxy
      * @throws HibernateException
      * @throws DAOException
      */
     public Object load(Class clazz, final Serializable id) throws HibernateException,
             DAOException;
 
     /**
      * Return the persistent instance of the given entity class with the given
      * identifier, obtaining the specified lock mode, assuming the instance
      * exists.
      * 
      * @param clazz
      * @param id
      * @param lockMode
      * @return the persistent instance or proxy
      * @throws HibernateException
      * @throws DAOException
      */
     public Object load(Class clazz, final Serializable id, LockMode lockMode)
             throws HibernateException, DAOException;
 
     /**
      * Read the persistent state associated with the given identifier into the
      * given transient instance.
      * 
      * @param object
      * @param id
      * @throws HibernateException
      * @throws DAOException
      */
     public void load(Object object, final Serializable id) throws HibernateException,
             DAOException;
 
     /**
      * Obtain the specified lock level upon the given object.
      * 
      * @param object -
      *            a persistent or transient instance
      * @param lockMode -
      *            the lock level
      * @throws HibernateException
      * @throws DAOException
      */
     public void lock(Object object, LockMode lockMode)
             throws HibernateException, DAOException;
 
     /**
      * Update the persistent instance with the identifier of the given transient
      * instance. If there is a persistent instance with the same identifier, an
      * exception is thrown. If the given transient instance has a null
      * identifier, an exception will be thrown.
      * 
      * @param object -
      *            a transient instance containing updated state
      * @throws HibernateException
      * @throws DAOException
      */
     public void update(Object object) throws HibernateException, DAOException;
 
     /**
      * Update the persistent state associated with the given identifier. An
      * exception is thrown if there is a persistent instance with the same
      * identifier in the current session.
      * 
      * @param object -
      *            a transient instance containing updated state
      * @param id -
      *            identifier of persistent instance
      * @throws HibernateException
      * @throws DAOException
      */
     public void update(Object object, final Serializable id)
             throws HibernateException, DAOException;
 
     /**
      * Copy the state of the given object onto the persistent object with the
      * same identifier. If there is no persistent instance currently associated
      * with the session, it will be loaded. Return the persistent instance. If
      * the given instance is unsaved or does not exist in the database, save it
      * and return it as a newly persistent instance. Otherwise, the given
      * instance does not become associated with the session.
      * 
      * @param object
      * @return an updated persistent instance
      * @throws HibernateException
      * @throws DAOException
      */
     public Object saveOrUpdateCopy(Object object) throws HibernateException,
             DAOException;
 
     /**
      * Copy the state of the given object onto the persistent object with the
      * given identifier. If there is no persistent instance currently associated
      * with the session, it will be loaded. Return the persistent instance. If
      * there is no database row with the given identifier, save the given
      * instance and return it as a newly persistent instance. Otherwise, the
      * given instance does not become associated with the session.
      * 
      * @param object -
      *            a persistent or transient instance with state to be copied
      * @param id -
      *            the identifier of the instance to copy to
      * @return an updated persistent instance
      * @throws HibernateException
      * @throws DAOException
      */
     public Object saveOrUpdateCopy(Object object, final Serializable id)
             throws HibernateException, DAOException;
 
     /**
      * Re-read the state of the given instance from the underlying database. It
      * is inadvisable to use this to implement long-running sessions that span
      * many business tasks. This method is, however, useful in certain special
      * circumstances.
      * 
      * @param object
      *            a persistent or transient instance
      * @throws HibernateException
      * @throws DAOException
      */
     public void refresh(Object object) throws HibernateException, DAOException;
 
     /**
      * Re-read the state of the given instance from the underlying database,
      * with the given LockMode. It is inadvisable to use this to implement
      * long-running sessions that span many business tasks. This method is,
      * however, useful in certain special circumstances.
      * 
      * @param object
      *            a persistent or transient instance
      * @param lockMode
      *            the lock mode to use
      * @throws HibernateException
      * @throws DAOException
      */
     public void refresh(Object object, LockMode lockMode)
             throws HibernateException, DAOException;
 
     /**
      * Persist the given transient instance, first assigning a generated
      * identifier.
      * 
      * @param object - -
      *            a transient instance of a persistent class
      * @return the generated identifier
      * @throws HibernateException
      */
     public Serializable save(Object object) throws HibernateException,
             DAOException;
 
     /**
      * Persist the given transient instance, using the given identifier.
      * 
      * @param object -
      *            a transient instance of a persistent class
      * @param id -
      *            an unused valid identifier
      * @throws HibernateException
      * @throws DAOException
      */
     public void save(Object object, final Serializable id) throws HibernateException,
             DAOException;
 
     /**
      * Either save() or update() the given instance, depending upon the value of
      * its identifier property. By default the instance is always saved. This
      * behaviour may be adjusted by specifying an unsaved-value attribute of the
      * identifier property mapping.
      * 
      * @param object -
      *            a transient instance containing new or updated state
      * @throws HibernateException
      * @throws DAOException
      */
     public void saveOrUpdate(Object object) throws HibernateException,
             DAOException;
 
 }

1		/**
2		* @(#)HibernateService.java
3		*
4		* JFoxSOAF, Service-Oriented Application Framework
5		*
6		* Copyright(c) JFoxSOAF Team
7		*
8		* Licensed under the GNU LGPL, Version 2.1 (the "License");
9		* you may not use this file except in compliance with the License.
10		* You may obtain a copy of the License at
11		*
12		* http://www.gnu.org/copyleft/lesser.html
13		*
14		* Unless required by applicable law or agreed to in writing, software
15		* distributed under the License is distributed on an "AS IS" BASIS,
16		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17		* See the License for the specific language governing permissions and
18		* limitations under the License.
19		*
20		* For more information, please visit:
21		* http://www.jfox.cn/confluence/display/JFoxSOAF/Home
22		* http://www.huihoo.org/jfox/jfoxsoaf
23		*/
24
25		package org.huihoo.jfox.soaf.services.persistence;
26
27		import java.io.Serializable;
28		import java.util.Iterator;
29		import java.util.List;
30
31		import net.sf.hibernate.HibernateException;
32		import net.sf.hibernate.LockMode;
33		import net.sf.hibernate.Session;
34		import net.sf.hibernate.SessionFactory;
35		import net.sf.hibernate.cfg.Configuration;
36		import net.sf.hibernate.type.Type;
37
38		import org.huihoo.jfox.soaf.exception.DAOException;
39
40		/**
41		* <p>
42		* Hibernate persistence service, Wrapper service for hibernate.
43		* </p>
44		*
45		* @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng </a>
46		* @version $Revision: 1.5 $ $Date: 2005/05/22 06:50:29 $
47		* @version Revision: 1.0
48		*/
49
50		public interface HibernateService {
51
52		/**
53		* Create database connection and open a Session on it.
54		*
55		* @return a Hibernate Session object
56		*/
57		public Session openSession() throws HibernateException;
58
59		/**
60		* Return hibernate configuration.
61		*
62		* @return a Hibernate Configuration object
63		*/
64		public Configuration getConfiguration() throws HibernateException;
65
66		/**
67		* Create SessionFactory.
68		*
69		* @return a Hibernate SessionFactory object
70		*/
71		public SessionFactory getSessionFactory() throws HibernateException;
72
73		/**
74		* commit transaction currently underway, and start new one ( as side effect
75		* hibernate session will be flushed )
76		*/
77		public void commit() throws HibernateException;
78
79		/**
80		* rollback active transaction if any was started. transaction will be reset
81		*
82		* @throws HibernateException if transaction can not be rolled back
83		*/
84		public void rollback() throws HibernateException;
85
86		/**
87		* normal session close. commit transaction is any
88		*/
89		public void closeSession() throws HibernateException;
90
91		/**
92		* reset and clean up everything. shall be used is something went wrong (
93		* for example you received hibernate exception )
94		*/
95		public void reset();
96
97		/**
98		* Check if this instance is associated with this Session
99		*
100		* @param object
101		* an instance of a persistent class
102		* @return true if the given instance is associated with this Session
103		* @throws HibernateException
104		* @throws DAOException
105		*/
106		public boolean contains(Object object) throws HibernateException,
107		DAOException;
108
109		/**
110		* Remove a persistent instance from the datastore.
111		*
112		* @param object
113		* @throws HibernateException
114		*/
115		public void delete(Object object) throws HibernateException, DAOException;
116
117		/**
118		* Remove a persistent instance from the datastore with lock mode.
119		*
120		* @param object
121		* @param lockMode
122		* @throws HibernateException
123		*/
124		public void delete(Object object, LockMode lockMode)
125		throws HibernateException, DAOException;
126
127		/**
128		* Delete all objects returned by the query. Return the number of objects
129		* deleted.
130		*
131		* @param query
132		* @return the number of instances deleted
133		* @throws HibernateException
134		* @throws DAOException
135		*/
136		public int delete(String query) throws HibernateException, DAOException;
137
138		/**
139		* Delete all objects returned by the query. Return the number of objects
140		* deleted.
141		*
142		* @param query
143		* @return the number of instances deleted
144		* @throws HibernateException
145		* @throws DAOException
146		*/
147		public int delete(String query, Object value, Type type)
148		throws HibernateException, DAOException;
149
150		/**
151		* Delete all objects returned by the query. Return the number of objects
152		* deleted.
153		*
154		* @param query
155		* @return the number of instances deleted
156		* @throws HibernateException
157		* @throws DAOException
158		*/
159		public int delete(String query, Object[] values, Type[] types)
160		throws HibernateException, DAOException;
161
162		/**
163		* Remove this instance from the session cache. Changes to the instance will
164		* not be synchronized with the database. This operation cascades to
165		* associated instances if the association is mapped with cascade="all" or
166		* cascade="all-delete-orphan".
167		*
168		* @param object
169		* object - a persistent instance
170		* @throws HibernateException
171		* @throws DAOException
172		*/
173		public void evict(Object object) throws HibernateException, DAOException;
174
175		/**
176		* Execute a query.
177		*
178		* @param query
179		* a query expressed in Hibernate's query language
180		* @return a distinct list of instances (or arrays of instances)
181		* @throws HibernateException
182		* @throws DAOException
183		*/
184		public List find(String query) throws HibernateException, DAOException;
185		/**
186		* Execute a query with bind parameters. Bind a value to a "?" parameter in
187		* the query string.
188		*
189		* @param query
190		* @param value
191		* @param type
192		* @return a distinct list of instances (or arrays of instances)
193		* @throws HibernateException
194		* @throws DAOException
195		*/
196		public List find(String query, Object value, Type type)
197		throws HibernateException, DAOException;
198
199		/**
200		* Execute a query with bind parameters. Binding an array of values to "?"
201		* parameters in the query string.
202		*
203		* @param query
204		* @param values
205		* @param types
206		* @return a distinct list of instances
207		* @throws HibernateException
208		* @throws DAOException
209		*/
210		public List find(String query, Object[] values, Type[] types)
211		throws HibernateException, DAOException;
212
213		/**
214		* Return the persistent instance of the given entity class with the given
215		* identifier, or null if there is no such persistent instance.
216		*
217		* @param clazz
218		* @param id
219		* @return a persistent instance or null
220		* @throws HibernateException
221		* @throws DAOException
222		*/
223		public Object get(Class clazz, final Serializable id) throws HibernateException,
224		DAOException;
225		/**
226		* Return the persistent instance of the given entity class with the given
227		* identifier, or null if there is no such persistent instance. Obtain the
228		* specified lock mode if the instance exists.
229		*
230		* @param clazz
231		* @param id
232		* @param lockMode
233		* @return a persistent instance or null
234		* @throws HibernateException
235		* @throws DAOException
236		*/
237		public Object get(Class clazz, final Serializable id, LockMode lockMode)
238		throws HibernateException, DAOException;
239
240		/**
241		* Execute a query and return the results in an iterator. If the query has
242		* multiple return values, values will be returned in an array of type
243		* Object[]. Entities returned as results are initialized on demand. The
244		* first SQL query returns identifiers only. So iterate() is usually a less
245		* efficient way to retrieve objects than find().
246		*
247		* @param query
248		* @return an iterator
249		* @throws HibernateException
250		* @throws DAOException
251		*/
252		public Iterator iterate(String query) throws HibernateException,
253		DAOException;
254
255		/**
256		* Execute a query and return the results in an iterator. Write the given
257		* value to "?" in the query string. If the query has multiple return
258		* values, values will be returned in an array of type Object[]. Entities
259		* returned as results are initialized on demand. The first SQL query
260		* returns identifiers only. So iterate() is usually a less efficient way to
261		* retrieve objects than find().
262		*
263		* @param query -
264		* the query string
265		* @param value -
266		* a value to be witten to a "?" placeholder in the query string
267		* @param type -
268		* the hibernate type of value
269		* @return an iterator
270		* @throws HibernateException
271		* @throws DAOException
272		*/
273		public Iterator iterate(String query, Object value, Type type)
274		throws HibernateException, DAOException;
275
276		/**
277		* Execute a query and return the results in an iterator. Write the given
278		* values to "?" in the query string. If the query has multiple return
279		* values, values will be returned in an array of type Object[]. Entities
280		* returned as results are initialized on demand. The first SQL query
281		* returns identifiers only. So iterate() is usually a less efficient way to
282		* retrieve objects than find().
283		*
284		* @param query
285		* @param values
286		* @param types
287		* @return
288		* @throws HibernateException
289		* @throws DAOException
290		*/
291		public Iterator iterate(String query, Object[] values, Type[] types)
292		throws HibernateException, DAOException;
293
294		/**
295		* Return the persistent instance of the given entity class with the given
296		* identifier, assuming that the instance exists. You should not use this
297		* method to determine if an instance exists (use find() instead). Use this
298		* only to retrieve an instance that you assume exists, where non-existence
299		* would be an actual error.
300		*
301		* @param clazz
302		* @param id
303		* @return the persistent instance or proxy
304		* @throws HibernateException
305		* @throws DAOException
306		*/
307		public Object load(Class clazz, final Serializable id) throws HibernateException,
308		DAOException;
309
310		/**
311		* Return the persistent instance of the given entity class with the given
312		* identifier, obtaining the specified lock mode, assuming the instance
313		* exists.
314		*
315		* @param clazz
316		* @param id
317		* @param lockMode
318		* @return the persistent instance or proxy
319		* @throws HibernateException
320		* @throws DAOException
321		*/
322		public Object load(Class clazz, final Serializable id, LockMode lockMode)
323		throws HibernateException, DAOException;
324
325		/**
326		* Read the persistent state associated with the given identifier into the
327		* given transient instance.
328		*
329		* @param object
330		* @param id
331		* @throws HibernateException
332		* @throws DAOException
333		*/
334		public void load(Object object, final Serializable id) throws HibernateException,
335		DAOException;
336
337		/**
338		* Obtain the specified lock level upon the given object.
339		*
340		* @param object -
341		* a persistent or transient instance
342		* @param lockMode -
343		* the lock level
344		* @throws HibernateException
345		* @throws DAOException
346		*/
347		public void lock(Object object, LockMode lockMode)
348		throws HibernateException, DAOException;
349
350		/**
351		* Update the persistent instance with the identifier of the given transient
352		* instance. If there is a persistent instance with the same identifier, an
353		* exception is thrown. If the given transient instance has a null
354		* identifier, an exception will be thrown.
355		*
356		* @param object -
357		* a transient instance containing updated state
358		* @throws HibernateException
359		* @throws DAOException
360		*/
361		public void update(Object object) throws HibernateException, DAOException;
362
363		/**
364		* Update the persistent state associated with the given identifier. An
365		* exception is thrown if there is a persistent instance with the same
366		* identifier in the current session.
367		*
368		* @param object -
369		* a transient instance containing updated state
370		* @param id -
371		* identifier of persistent instance
372		* @throws HibernateException
373		* @throws DAOException
374		*/
375		public void update(Object object, final Serializable id)
376		throws HibernateException, DAOException;
377
378		/**
379		* Copy the state of the given object onto the persistent object with the
380		* same identifier. If there is no persistent instance currently associated
381		* with the session, it will be loaded. Return the persistent instance. If
382		* the given instance is unsaved or does not exist in the database, save it
383		* and return it as a newly persistent instance. Otherwise, the given
384		* instance does not become associated with the session.
385		*
386		* @param object
387		* @return an updated persistent instance
388		* @throws HibernateException
389		* @throws DAOException
390		*/
391		public Object saveOrUpdateCopy(Object object) throws HibernateException,
392		DAOException;
393
394		/**
395		* Copy the state of the given object onto the persistent object with the
396		* given identifier. If there is no persistent instance currently associated
397		* with the session, it will be loaded. Return the persistent instance. If
398		* there is no database row with the given identifier, save the given
399		* instance and return it as a newly persistent instance. Otherwise, the
400		* given instance does not become associated with the session.
401		*
402		* @param object -
403		* a persistent or transient instance with state to be copied
404		* @param id -
405		* the identifier of the instance to copy to
406		* @return an updated persistent instance
407		* @throws HibernateException
408		* @throws DAOException
409		*/
410		public Object saveOrUpdateCopy(Object object, final Serializable id)
411		throws HibernateException, DAOException;
412
413		/**
414		* Re-read the state of the given instance from the underlying database. It
415		* is inadvisable to use this to implement long-running sessions that span
416		* many business tasks. This method is, however, useful in certain special
417		* circumstances.
418		*
419		* @param object
420		* a persistent or transient instance
421		* @throws HibernateException
422		* @throws DAOException
423		*/
424		public void refresh(Object object) throws HibernateException, DAOException;
425
426		/**
427		* Re-read the state of the given instance from the underlying database,
428		* with the given LockMode. It is inadvisable to use this to implement
429		* long-running sessions that span many business tasks. This method is,
430		* however, useful in certain special circumstances.
431		*
432		* @param object
433		* a persistent or transient instance
434		* @param lockMode
435		* the lock mode to use
436		* @throws HibernateException
437		* @throws DAOException
438		*/
439		public void refresh(Object object, LockMode lockMode)
440		throws HibernateException, DAOException;
441
442		/**
443		* Persist the given transient instance, first assigning a generated
444		* identifier.
445		*
446		* @param object - -
447		* a transient instance of a persistent class
448		* @return the generated identifier
449		* @throws HibernateException
450		*/
451		public Serializable save(Object object) throws HibernateException,
452		DAOException;
453
454		/**
455		* Persist the given transient instance, using the given identifier.
456		*
457		* @param object -
458		* a transient instance of a persistent class
459		* @param id -
460		* an unused valid identifier
461		* @throws HibernateException
462		* @throws DAOException
463		*/
464		public void save(Object object, final Serializable id) throws HibernateException,
465		DAOException;
466
467		/**
468		* Either save() or update() the given instance, depending upon the value of
469		* its identifier property. By default the instance is always saved. This
470		* behaviour may be adjusted by specifying an unsaved-value attribute of the
471		* identifier property mapping.
472		*
473		* @param object -
474		* a transient instance containing new or updated state
475		* @throws HibernateException
476		* @throws DAOException
477		*/
478		public void saveOrUpdate(Object object) throws HibernateException,
479		DAOException;
480
481		}