1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.dao.orm.hibernate;
24  
25  import com.liferay.portal.kernel.util.PortalClassLoaderUtil;
26  
27  import java.io.Serializable;
28  
29  import java.lang.Class;
30  import java.lang.Object;
31  import java.lang.String;
32  
33  import java.sql.Connection;
34  
35  import org.hibernate.CacheMode;
36  import org.hibernate.Criteria;
37  import org.hibernate.EntityMode;
38  import org.hibernate.Filter;
39  import org.hibernate.FlushMode;
40  import org.hibernate.HibernateException;
41  import org.hibernate.LockMode;
42  import org.hibernate.Query;
43  import org.hibernate.ReplicationMode;
44  import org.hibernate.SQLQuery;
45  import org.hibernate.Session;
46  import org.hibernate.SessionFactory;
47  import org.hibernate.Transaction;
48  import org.hibernate.stat.SessionStatistics;
49  
50  /**
51   * <a href="LiferaySession.java.html"><b><i>View Source</i></b></a>
52   *
53   * <p>
54   * See http://support.liferay.com/browse/LEP-2996.
55   * </p>
56   *
57   * @author Brian Wing Shun Chan
58   *
59   */
60  public class LiferaySession implements Session {
61  
62      public LiferaySession(Session session) {
63          _session = session;
64      }
65  
66      public Session getHibernateSession() {
67          return _session;
68      }
69  
70      public Transaction beginTransaction() throws HibernateException {
71          return _session.beginTransaction();
72      }
73  
74      public void cancelQuery() throws HibernateException {
75          _session.cancelQuery();
76      }
77  
78      public void clear() {
79          _session.clear();
80      }
81  
82      public Connection close() throws HibernateException {
83          return _session.close();
84      }
85  
86      /**
87       * @deprecated
88       */
89      public Connection connection() throws HibernateException {
90          ClassLoader contextClassLoader =
91              Thread.currentThread().getContextClassLoader();
92  
93          try {
94              ClassLoader portalClassLoader =
95                  PortalClassLoaderUtil.getClassLoader();
96  
97              Thread.currentThread().setContextClassLoader(portalClassLoader);
98  
99              Connection connection = _session.connection();
100 
101             return connection;
102         }
103         finally {
104             Thread.currentThread().setContextClassLoader(contextClassLoader);
105         }
106     }
107 
108     public boolean contains(Object object) {
109         return _session.contains(object);
110     }
111 
112     public Criteria createCriteria(Class persistentClass) {
113         return _session.createCriteria(persistentClass);
114     }
115 
116     public Criteria createCriteria(Class persistentClass, String alias) {
117         return _session.createCriteria(persistentClass, alias);
118     }
119 
120     public Criteria createCriteria(String entityName) {
121         return _session.createCriteria(entityName);
122     }
123 
124     public Criteria createCriteria(String entityName, String alias) {
125         return _session.createCriteria(entityName, alias);
126     }
127 
128     public Query createFilter(Object collection, String queryString)
129         throws HibernateException {
130 
131         return _session.createFilter(collection, queryString);
132     }
133 
134     public Query createQuery(String queryString) throws HibernateException {
135         return _session.createQuery(queryString);
136     }
137 
138     public SQLQuery createSQLQuery(String queryString)
139         throws HibernateException {
140 
141         return _session.createSQLQuery(queryString);
142     }
143 
144     public void delete(Object object) throws HibernateException {
145         _session.delete(object);
146     }
147 
148     public void delete(String entityName, Object object)
149         throws HibernateException {
150 
151         _session.delete(entityName, object);
152     }
153 
154     public void disableFilter(String filterName) {
155         _session.disableFilter(filterName);
156     }
157 
158     public Connection disconnect() throws HibernateException {
159         return _session.disconnect();
160     }
161 
162     public Filter enableFilter(String filterName) {
163         return _session.enableFilter(filterName);
164     }
165 
166     public void evict(Object object) throws HibernateException {
167         _session.evict(object);
168     }
169 
170     public void flush() throws HibernateException {
171         _session.flush();
172     }
173 
174     public Object get(Class clazz, Serializable id) throws HibernateException {
175         return _session.get(clazz, id);
176     }
177 
178     public Object get(Class clazz, Serializable id, LockMode lockMode)
179         throws HibernateException {
180 
181         return _session.get(clazz, id, lockMode);
182     }
183 
184     public Object get(String entityName, Serializable id)
185         throws HibernateException {
186 
187         return _session.get(entityName, id);
188     }
189 
190     public Object get(String entityName, Serializable id, LockMode lockMode)
191         throws HibernateException {
192 
193         return _session.get(entityName, id, lockMode);
194     }
195 
196     public CacheMode getCacheMode() {
197         return _session.getCacheMode();
198     }
199 
200     public LockMode getCurrentLockMode(Object object)
201         throws HibernateException {
202 
203         return _session.getCurrentLockMode(object);
204     }
205 
206     public Filter getEnabledFilter(String filterName) {
207         return _session.getEnabledFilter(filterName);
208     }
209 
210     public EntityMode getEntityMode() {
211         return _session.getEntityMode();
212     }
213 
214     public String getEntityName(Object object) throws HibernateException {
215         return _session.getEntityName(object);
216     }
217 
218     public FlushMode getFlushMode() {
219         return _session.getFlushMode();
220     }
221 
222     public Serializable getIdentifier(Object object) throws HibernateException {
223         return _session.getIdentifier(object);
224     }
225 
226     public Query getNamedQuery(String queryName) throws HibernateException {
227         return _session.getNamedQuery(queryName);
228     }
229 
230     public Session getSession(EntityMode entityMode) {
231         return _session.getSession(entityMode);
232     }
233 
234     public SessionFactory getSessionFactory() {
235         return _session.getSessionFactory();
236     }
237 
238     public SessionStatistics getStatistics() {
239         return _session.getStatistics();
240     }
241 
242     public Transaction getTransaction() {
243         return _session.getTransaction();
244     }
245 
246     public boolean isConnected() {
247         return _session.isConnected();
248     }
249 
250     public boolean isDirty() throws HibernateException {
251         return _session.isDirty();
252     }
253 
254     public boolean isOpen() {
255         return _session.isOpen();
256     }
257 
258     public Object load(Class theClass, Serializable id, LockMode lockMode)
259         throws HibernateException {
260 
261         return _session.load(theClass, id, lockMode);
262     }
263 
264     public Object load(String entityName, Serializable id, LockMode lockMode)
265         throws HibernateException {
266 
267         return _session.load(entityName, id, lockMode);
268     }
269 
270     public Object load(Class theClass, Serializable id)
271         throws HibernateException {
272 
273         return _session.load(theClass, id);
274     }
275 
276     public Object load(String entityName, Serializable id)
277         throws HibernateException {
278 
279         return _session.load(entityName, id);
280     }
281 
282     public void load(Object object, Serializable id) throws HibernateException {
283         _session.load(object, id);
284     }
285 
286     public void lock(Object object, LockMode lockMode)
287         throws HibernateException {
288 
289         _session.lock(object, lockMode);
290     }
291 
292     public void lock(String entityName, Object object, LockMode lockMode)
293         throws HibernateException {
294 
295         _session.lock(entityName, object, lockMode);
296     }
297 
298     public Object merge(Object object) throws HibernateException {
299         return _session.merge(object);
300     }
301 
302     public Object merge(String entityName, Object object)
303         throws HibernateException {
304 
305         return _session.merge(entityName, object);
306     }
307 
308     public void persist(Object object) throws HibernateException {
309         _session.persist(object);
310     }
311 
312     public void persist(String entityName, Object object)
313         throws HibernateException {
314 
315         _session.persist(entityName, object);
316     }
317 
318     /**
319      * @deprecated
320      */
321     public void reconnect() throws HibernateException {
322         _session.reconnect();
323     }
324 
325     public void reconnect(Connection connection) throws HibernateException {
326         _session.reconnect(connection);
327     }
328 
329     public void refresh(Object object) throws HibernateException {
330         _session.refresh(object);
331     }
332 
333     public void refresh(Object object, LockMode lockMode)
334         throws HibernateException {
335 
336         _session.refresh(object, lockMode);
337     }
338 
339     public void replicate(Object object, ReplicationMode replicationMode)
340         throws HibernateException {
341 
342         _session.replicate(object, replicationMode);
343     }
344 
345     public void replicate(
346             String entityName, Object object, ReplicationMode replicationMode)
347         throws HibernateException {
348 
349         _session.replicate(entityName, object, replicationMode);
350     }
351 
352     public Serializable save(Object object) throws HibernateException {
353         return _session.save(object);
354     }
355 
356     public Serializable save(String entityName, Object object)
357         throws HibernateException {
358         return _session.save(entityName, object);
359     }
360 
361     public void saveOrUpdate(Object object) throws HibernateException {
362         _session.saveOrUpdate(object);
363     }
364 
365     public void saveOrUpdate(String entityName, Object object)
366         throws HibernateException {
367 
368         _session.saveOrUpdate(entityName, object);
369     }
370 
371     public void setCacheMode(CacheMode cacheMode) {
372         _session.setCacheMode(cacheMode);
373     }
374 
375     public void setFlushMode(FlushMode flushMode) {
376         _session.setFlushMode(flushMode);
377     }
378 
379     public void setReadOnly(Object entity, boolean readOnly) {
380         _session.setReadOnly(entity, readOnly);
381     }
382 
383     public void update(Object object) throws HibernateException {
384         _session.update(object);
385     }
386 
387     public void update(String entityName, Object object)
388         throws HibernateException {
389 
390         _session.update(entityName, object);
391     }
392 
393     private Session _session;
394 
395 }