1   /**
2    * Copyright (c) 2000-2009 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          Thread currentThread = Thread.currentThread();
91  
92          ClassLoader contextClassLoader = currentThread.getContextClassLoader();
93  
94          try {
95              ClassLoader portalClassLoader =
96                  PortalClassLoaderUtil.getClassLoader();
97  
98              currentThread.setContextClassLoader(portalClassLoader);
99  
100             Connection connection = _session.connection();
101 
102             return connection;
103         }
104         finally {
105             currentThread.setContextClassLoader(contextClassLoader);
106         }
107     }
108 
109     public boolean contains(Object object) {
110         return _session.contains(object);
111     }
112 
113     public Criteria createCriteria(Class persistentClass) {
114         return _session.createCriteria(persistentClass);
115     }
116 
117     public Criteria createCriteria(Class persistentClass, String alias) {
118         return _session.createCriteria(persistentClass, alias);
119     }
120 
121     public Criteria createCriteria(String entityName) {
122         return _session.createCriteria(entityName);
123     }
124 
125     public Criteria createCriteria(String entityName, String alias) {
126         return _session.createCriteria(entityName, alias);
127     }
128 
129     public Query createFilter(Object collection, String queryString)
130         throws HibernateException {
131 
132         return _session.createFilter(collection, queryString);
133     }
134 
135     public Query createQuery(String queryString) throws HibernateException {
136         return _session.createQuery(queryString);
137     }
138 
139     public SQLQuery createSQLQuery(String queryString)
140         throws HibernateException {
141 
142         return _session.createSQLQuery(queryString);
143     }
144 
145     public void delete(Object object) throws HibernateException {
146         _session.delete(object);
147     }
148 
149     public void delete(String entityName, Object object)
150         throws HibernateException {
151 
152         _session.delete(entityName, object);
153     }
154 
155     public void disableFilter(String filterName) {
156         _session.disableFilter(filterName);
157     }
158 
159     public Connection disconnect() throws HibernateException {
160         return _session.disconnect();
161     }
162 
163     public Filter enableFilter(String filterName) {
164         return _session.enableFilter(filterName);
165     }
166 
167     public void evict(Object object) throws HibernateException {
168         _session.evict(object);
169     }
170 
171     public void flush() throws HibernateException {
172         _session.flush();
173     }
174 
175     public Object get(Class clazz, Serializable id) throws HibernateException {
176         return _session.get(clazz, id);
177     }
178 
179     public Object get(Class clazz, Serializable id, LockMode lockMode)
180         throws HibernateException {
181 
182         return _session.get(clazz, id, lockMode);
183     }
184 
185     public Object get(String entityName, Serializable id)
186         throws HibernateException {
187 
188         return _session.get(entityName, id);
189     }
190 
191     public Object get(String entityName, Serializable id, LockMode lockMode)
192         throws HibernateException {
193 
194         return _session.get(entityName, id, lockMode);
195     }
196 
197     public CacheMode getCacheMode() {
198         return _session.getCacheMode();
199     }
200 
201     public LockMode getCurrentLockMode(Object object)
202         throws HibernateException {
203 
204         return _session.getCurrentLockMode(object);
205     }
206 
207     public Filter getEnabledFilter(String filterName) {
208         return _session.getEnabledFilter(filterName);
209     }
210 
211     public EntityMode getEntityMode() {
212         return _session.getEntityMode();
213     }
214 
215     public String getEntityName(Object object) throws HibernateException {
216         return _session.getEntityName(object);
217     }
218 
219     public FlushMode getFlushMode() {
220         return _session.getFlushMode();
221     }
222 
223     public Serializable getIdentifier(Object object) throws HibernateException {
224         return _session.getIdentifier(object);
225     }
226 
227     public Query getNamedQuery(String queryName) throws HibernateException {
228         return _session.getNamedQuery(queryName);
229     }
230 
231     public Session getSession(EntityMode entityMode) {
232         return _session.getSession(entityMode);
233     }
234 
235     public SessionFactory getSessionFactory() {
236         return _session.getSessionFactory();
237     }
238 
239     public SessionStatistics getStatistics() {
240         return _session.getStatistics();
241     }
242 
243     public Transaction getTransaction() {
244         return _session.getTransaction();
245     }
246 
247     public boolean isConnected() {
248         return _session.isConnected();
249     }
250 
251     public boolean isDirty() throws HibernateException {
252         return _session.isDirty();
253     }
254 
255     public boolean isOpen() {
256         return _session.isOpen();
257     }
258 
259     public Object load(Class theClass, Serializable id, LockMode lockMode)
260         throws HibernateException {
261 
262         return _session.load(theClass, id, lockMode);
263     }
264 
265     public Object load(String entityName, Serializable id, LockMode lockMode)
266         throws HibernateException {
267 
268         return _session.load(entityName, id, lockMode);
269     }
270 
271     public Object load(Class theClass, Serializable id)
272         throws HibernateException {
273 
274         return _session.load(theClass, id);
275     }
276 
277     public Object load(String entityName, Serializable id)
278         throws HibernateException {
279 
280         return _session.load(entityName, id);
281     }
282 
283     public void load(Object object, Serializable id) throws HibernateException {
284         _session.load(object, id);
285     }
286 
287     public void lock(Object object, LockMode lockMode)
288         throws HibernateException {
289 
290         _session.lock(object, lockMode);
291     }
292 
293     public void lock(String entityName, Object object, LockMode lockMode)
294         throws HibernateException {
295 
296         _session.lock(entityName, object, lockMode);
297     }
298 
299     public Object merge(Object object) throws HibernateException {
300         return _session.merge(object);
301     }
302 
303     public Object merge(String entityName, Object object)
304         throws HibernateException {
305 
306         return _session.merge(entityName, object);
307     }
308 
309     public void persist(Object object) throws HibernateException {
310         _session.persist(object);
311     }
312 
313     public void persist(String entityName, Object object)
314         throws HibernateException {
315 
316         _session.persist(entityName, object);
317     }
318 
319     /**
320      * @deprecated
321      */
322     public void reconnect() throws HibernateException {
323         _session.reconnect();
324     }
325 
326     public void reconnect(Connection connection) throws HibernateException {
327         _session.reconnect(connection);
328     }
329 
330     public void refresh(Object object) throws HibernateException {
331         _session.refresh(object);
332     }
333 
334     public void refresh(Object object, LockMode lockMode)
335         throws HibernateException {
336 
337         _session.refresh(object, lockMode);
338     }
339 
340     public void replicate(Object object, ReplicationMode replicationMode)
341         throws HibernateException {
342 
343         _session.replicate(object, replicationMode);
344     }
345 
346     public void replicate(
347             String entityName, Object object, ReplicationMode replicationMode)
348         throws HibernateException {
349 
350         _session.replicate(entityName, object, replicationMode);
351     }
352 
353     public Serializable save(Object object) throws HibernateException {
354         return _session.save(object);
355     }
356 
357     public Serializable save(String entityName, Object object)
358         throws HibernateException {
359         return _session.save(entityName, object);
360     }
361 
362     public void saveOrUpdate(Object object) throws HibernateException {
363         _session.saveOrUpdate(object);
364     }
365 
366     public void saveOrUpdate(String entityName, Object object)
367         throws HibernateException {
368 
369         _session.saveOrUpdate(entityName, object);
370     }
371 
372     public void setCacheMode(CacheMode cacheMode) {
373         _session.setCacheMode(cacheMode);
374     }
375 
376     public void setFlushMode(FlushMode flushMode) {
377         _session.setFlushMode(flushMode);
378     }
379 
380     public void setReadOnly(Object entity, boolean readOnly) {
381         _session.setReadOnly(entity, readOnly);
382     }
383 
384     public void update(Object object) throws HibernateException {
385         _session.update(object);
386     }
387 
388     public void update(String entityName, Object object)
389         throws HibernateException {
390 
391         _session.update(entityName, object);
392     }
393 
394     private Session _session;
395 
396 }