[seam-commits] Seam SVN: r13922 - branches/community/Seam_2_2/src/main/org/jboss/seam/persistence.
seam-commits at lists.jboss.org
seam-commits at lists.jboss.org
Mon Nov 22 08:19:40 EST 2010
Author: manaRH
Date: 2010-11-22 08:19:40 -0500 (Mon, 22 Nov 2010)
New Revision: 13922
Modified:
branches/community/Seam_2_2/src/main/org/jboss/seam/persistence/HibernatePersistenceProvider.java
branches/community/Seam_2_2/src/main/org/jboss/seam/persistence/HibernateSessionInvocationHandler.java
Log:
JBSEAM-4698, JBSEAM-4714
Modified: branches/community/Seam_2_2/src/main/org/jboss/seam/persistence/HibernatePersistenceProvider.java
===================================================================
--- branches/community/Seam_2_2/src/main/org/jboss/seam/persistence/HibernatePersistenceProvider.java 2010-11-22 11:26:19 UTC (rev 13921)
+++ branches/community/Seam_2_2/src/main/org/jboss/seam/persistence/HibernatePersistenceProvider.java 2010-11-22 13:19:40 UTC (rev 13922)
@@ -17,7 +17,6 @@
import org.hibernate.TransientObjectException;
import org.hibernate.metadata.ClassMetadata;
import org.hibernate.proxy.HibernateProxy;
-import org.hibernate.search.FullTextSession;
import org.hibernate.type.VersionType;
import org.jboss.seam.Component;
import org.jboss.seam.Entity;
@@ -122,7 +121,7 @@
{
return (Session) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class[] { HibernateSessionProxy.class },
- new HibernateSessionInvocationHandler(session, (FullTextSession) session) );
+ new HibernateSessionInvocationHandler(session));//, (FullTextSession) session) );
}
}
else
@@ -136,7 +135,7 @@
else {
return (Session) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class[] { FULL_TEXT_SESSION_PROXY_CLASS },
- new HibernateSessionInvocationHandler( session, (FullTextSession) FULL_TEXT_SESSION_CONSTRUCTOR.invoke(null, session) ) );
+ new HibernateSessionInvocationHandler( (Session) FULL_TEXT_SESSION_CONSTRUCTOR.invoke(null, session) ) );
}
}
catch(Exception e) {
@@ -148,7 +147,7 @@
else {
return (Session) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class[] { HibernateSessionProxy.class },
- new HibernateSessionInvocationHandler( session, null) );
+ new HibernateSessionInvocationHandler( session) );
}
}
}
Modified: branches/community/Seam_2_2/src/main/org/jboss/seam/persistence/HibernateSessionInvocationHandler.java
===================================================================
--- branches/community/Seam_2_2/src/main/org/jboss/seam/persistence/HibernateSessionInvocationHandler.java 2010-11-22 11:26:19 UTC (rev 13921)
+++ branches/community/Seam_2_2/src/main/org/jboss/seam/persistence/HibernateSessionInvocationHandler.java 2010-11-22 13:19:40 UTC (rev 13922)
@@ -4,10 +4,7 @@
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.lang.reflect.TypeVariable;
import java.sql.Connection;
-import java.util.Arrays;
-import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -46,7 +43,6 @@
import org.hibernate.jdbc.Work;
import org.hibernate.loader.custom.CustomQuery;
import org.hibernate.persister.entity.EntityPersister;
-import org.hibernate.search.FullTextSession;
import org.hibernate.stat.SessionStatistics;
import org.hibernate.type.Type;
@@ -64,71 +60,12 @@
public class HibernateSessionInvocationHandler implements InvocationHandler, Serializable, EventSource
{
- private FullTextSession ftDelegate;
private Session delegate;
- private Map<String, Method> eventSourceMethods = new HashMap<String, Method>();
-
- public HibernateSessionInvocationHandler(Session paramDelegate, FullTextSession searchDelegate)
+ public HibernateSessionInvocationHandler(Session paramDelegate)
{
- this.ftDelegate = searchDelegate;
this.delegate = paramDelegate;
- buildEventSourceMethodMetadata();
}
-
- private void buildEventSourceMethodMetadata(){
- Method[] methods = EventSource.class.getDeclaredMethods();
- for (Method declaredMethod : methods)
- {
- eventSourceMethods.put(declaredMethod.getName(), declaredMethod);
- }
- }
-
- /**
- * Get the proper delegate based on {@link org.hibernate.event.EventSource}
- * or {@link org.hibernate.search.FullTextSession}
- *
- * @param method
- * @return proper delegate based on {@link org.hibernate.event.EventSource}
- * or {@link org.hibernate.search.FullTextSession}
- */
- Object getDelegate(Method method)
- {
- if (isPureEventSourceMethod(method))
- {
- return delegate;
- }
- else
- {
- return ftDelegate;
- }
- }
-
- /**
- * Detects if Method is hosted on EventSource and *not* any of its interfaces
- * if true returns true otherwise return false
- *
- * @param method
- * @return true if it is on declared on
- * {@link org.hibernate.event.EventSource} otherwise return false
- */
- boolean isPureEventSourceMethod(Method method)
- {
- if ( eventSourceMethods.containsKey(method.getName()))
- {
- Method declMethod = eventSourceMethods.get(method);
- if (declMethod != null)
- {
- TypeVariable<Method>[] pars = declMethod.getTypeParameters();
- if (Arrays.equals(method.getTypeParameters(), pars))
- {
- return true;
- }
- }
- }
-
- return false;
- }
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
@@ -142,7 +79,7 @@
{
return handleReconnectNoArg(method);
}
- return method.invoke(getDelegate(method), args);
+ return method.invoke(delegate, args);
}
catch (InvocationTargetException e)
{
@@ -154,7 +91,8 @@
{
if (args[0] == null)
{
- return method.invoke(getDelegate(method), args);
+ //return method.invoke(getDelegate(method), args);
+ return method.invoke(delegate, args);
}
String ejbql = (String) args[0];
if (ejbql.indexOf('#') > 0)
@@ -162,7 +100,8 @@
QueryParser qp = new QueryParser(ejbql);
Object[] newArgs = args.clone();
newArgs[0] = qp.getEjbql();
- Query query = (Query) method.invoke(getDelegate(method), newArgs);
+ //Query query = (Query) method.invoke(getDelegate(method), newArgs);
+ Query query = (Query) method.invoke(delegate, newArgs);
for (int i = 0; i < qp.getParameterValueBindings().size(); i++)
{
query.setParameter(QueryParser.getParameterName(i), qp.getParameterValueBindings().get(i).getValue());
@@ -171,7 +110,7 @@
}
else
{
- return method.invoke(getDelegate(method), args);
+ return method.invoke(delegate, args);
}
}
@@ -182,408 +121,408 @@
public Interceptor getInterceptor()
{
- return ((SessionImplementor) ftDelegate).getInterceptor();
+ return ((SessionImplementor) delegate).getInterceptor();
}
public void setAutoClear(boolean paramBoolean)
{
- ((SessionImplementor) ftDelegate).setAutoClear(paramBoolean);
+ ((SessionImplementor) delegate).setAutoClear(paramBoolean);
}
public boolean isTransactionInProgress()
{
- return ((SessionImplementor) ftDelegate).isTransactionInProgress();
+ return ((SessionImplementor) delegate).isTransactionInProgress();
}
public void initializeCollection(PersistentCollection paramPersistentCollection, boolean paramBoolean) throws HibernateException
{
- ((SessionImplementor) ftDelegate).initializeCollection(paramPersistentCollection, paramBoolean);
+ ((SessionImplementor) delegate).initializeCollection(paramPersistentCollection, paramBoolean);
}
public Object internalLoad(String paramString, Serializable paramSerializable, boolean paramBoolean1, boolean paramBoolean2) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).internalLoad(paramString, paramSerializable, paramBoolean1, paramBoolean2);
+ return ((SessionImplementor) delegate).internalLoad(paramString, paramSerializable, paramBoolean1, paramBoolean2);
}
public Object immediateLoad(String paramString, Serializable paramSerializable) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).immediateLoad(paramString, paramSerializable);
+ return ((SessionImplementor) delegate).immediateLoad(paramString, paramSerializable);
}
public long getTimestamp()
{
- return ((SessionImplementor) ftDelegate).getTimestamp();
+ return ((SessionImplementor) delegate).getTimestamp();
}
public SessionFactoryImplementor getFactory()
{
- return ((SessionImplementor) ftDelegate).getFactory();
+ return ((SessionImplementor) delegate).getFactory();
}
public Batcher getBatcher()
{
- return ((SessionImplementor) ftDelegate).getBatcher();
+ return ((SessionImplementor) delegate).getBatcher();
}
public List list(String paramString, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).list(paramString, paramQueryParameters);
+ return ((SessionImplementor) delegate).list(paramString, paramQueryParameters);
}
public Iterator iterate(String paramString, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).iterate(paramString, paramQueryParameters);
+ return ((SessionImplementor) delegate).iterate(paramString, paramQueryParameters);
}
public ScrollableResults scroll(String paramString, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).scroll(paramString, paramQueryParameters);
+ return ((SessionImplementor) delegate).scroll(paramString, paramQueryParameters);
}
public ScrollableResults scroll(CriteriaImpl paramCriteriaImpl, ScrollMode paramScrollMode)
{
- return ((SessionImplementor) ftDelegate).scroll(paramCriteriaImpl, paramScrollMode);
+ return ((SessionImplementor) delegate).scroll(paramCriteriaImpl, paramScrollMode);
}
public List list(CriteriaImpl paramCriteriaImpl)
{
- return ((SessionImplementor) ftDelegate).list(paramCriteriaImpl);
+ return ((SessionImplementor) delegate).list(paramCriteriaImpl);
}
public List listFilter(Object paramObject, String paramString, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).listFilter(paramObject, paramString, paramQueryParameters);
+ return ((SessionImplementor) delegate).listFilter(paramObject, paramString, paramQueryParameters);
}
public Iterator iterateFilter(Object paramObject, String paramString, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).iterateFilter(paramObject, paramString, paramQueryParameters);
+ return ((SessionImplementor) delegate).iterateFilter(paramObject, paramString, paramQueryParameters);
}
public EntityPersister getEntityPersister(String paramString, Object paramObject) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).getEntityPersister(paramString, paramObject);
+ return ((SessionImplementor) delegate).getEntityPersister(paramString, paramObject);
}
public Object getEntityUsingInterceptor(EntityKey paramEntityKey) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).getEntityUsingInterceptor(paramEntityKey);
+ return ((SessionImplementor) delegate).getEntityUsingInterceptor(paramEntityKey);
}
public void afterTransactionCompletion(boolean paramBoolean, Transaction paramTransaction)
{
- ((SessionImplementor) ftDelegate).afterTransactionCompletion(paramBoolean, paramTransaction);
+ ((SessionImplementor) delegate).afterTransactionCompletion(paramBoolean, paramTransaction);
}
public void beforeTransactionCompletion(Transaction paramTransaction)
{
- ((SessionImplementor) ftDelegate).beforeTransactionCompletion(paramTransaction) ;
+ ((SessionImplementor) delegate).beforeTransactionCompletion(paramTransaction) ;
}
public Serializable getContextEntityIdentifier(Object paramObject)
{
- return ((SessionImplementor) ftDelegate).getContextEntityIdentifier(paramObject);
+ return ((SessionImplementor) delegate).getContextEntityIdentifier(paramObject);
}
public String bestGuessEntityName(Object paramObject)
{
- return ((SessionImplementor) ftDelegate).bestGuessEntityName(paramObject);
+ return ((SessionImplementor) delegate).bestGuessEntityName(paramObject);
}
public String guessEntityName(Object paramObject) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).guessEntityName(paramObject);
+ return ((SessionImplementor) delegate).guessEntityName(paramObject);
}
public Object instantiate(String paramString, Serializable paramSerializable) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).instantiate(paramString, paramSerializable);
+ return ((SessionImplementor) delegate).instantiate(paramString, paramSerializable);
}
public List listCustomQuery(CustomQuery paramCustomQuery, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).listCustomQuery(paramCustomQuery, paramQueryParameters);
+ return ((SessionImplementor) delegate).listCustomQuery(paramCustomQuery, paramQueryParameters);
}
public ScrollableResults scrollCustomQuery(CustomQuery paramCustomQuery, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).scrollCustomQuery(paramCustomQuery, paramQueryParameters);
+ return ((SessionImplementor) delegate).scrollCustomQuery(paramCustomQuery, paramQueryParameters);
}
public List list(NativeSQLQuerySpecification paramNativeSQLQuerySpecification, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).list(paramNativeSQLQuerySpecification, paramQueryParameters);
+ return ((SessionImplementor) delegate).list(paramNativeSQLQuerySpecification, paramQueryParameters);
}
public ScrollableResults scroll(NativeSQLQuerySpecification paramNativeSQLQuerySpecification, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).scroll(paramNativeSQLQuerySpecification, paramQueryParameters);
+ return ((SessionImplementor) delegate).scroll(paramNativeSQLQuerySpecification, paramQueryParameters);
}
public Object getFilterParameterValue(String paramString)
{
- return ((SessionImplementor) ftDelegate).getFilterParameterValue(paramString);
+ return ((SessionImplementor) delegate).getFilterParameterValue(paramString);
}
public Type getFilterParameterType(String paramString)
{
- return ((SessionImplementor) ftDelegate).getFilterParameterType(paramString);
+ return ((SessionImplementor) delegate).getFilterParameterType(paramString);
}
public Map getEnabledFilters()
{
- return ((SessionImplementor) ftDelegate).getEnabledFilters();
+ return ((SessionImplementor) delegate).getEnabledFilters();
}
public int getDontFlushFromFind()
{
- return ((SessionImplementor) ftDelegate).getDontFlushFromFind();
+ return ((SessionImplementor) delegate).getDontFlushFromFind();
}
public EventListeners getListeners()
{
- return ((SessionImplementor) ftDelegate).getListeners();
+ return ((SessionImplementor) delegate).getListeners();
}
public PersistenceContext getPersistenceContext()
{
- return ((SessionImplementor) ftDelegate).getPersistenceContext();
+ return ((SessionImplementor) delegate).getPersistenceContext();
}
public int executeUpdate(String paramString, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).executeUpdate(paramString, paramQueryParameters);
+ return ((SessionImplementor) delegate).executeUpdate(paramString, paramQueryParameters);
}
public int executeNativeUpdate(NativeSQLQuerySpecification paramNativeSQLQuerySpecification, QueryParameters paramQueryParameters) throws HibernateException
{
- return ((SessionImplementor) ftDelegate).executeNativeUpdate(paramNativeSQLQuerySpecification, paramQueryParameters);
+ return ((SessionImplementor) delegate).executeNativeUpdate(paramNativeSQLQuerySpecification, paramQueryParameters);
}
public EntityMode getEntityMode()
{
- return ((SessionImplementor) ftDelegate).getEntityMode();
+ return ((SessionImplementor) delegate).getEntityMode();
}
public CacheMode getCacheMode()
{
- return ((SessionImplementor) ftDelegate).getCacheMode();
+ return ((SessionImplementor) delegate).getCacheMode();
}
public void setCacheMode(CacheMode paramCacheMode)
{
- ((SessionImplementor) ftDelegate).setCacheMode(paramCacheMode);
+ ((SessionImplementor) delegate).setCacheMode(paramCacheMode);
}
public boolean isOpen()
{
- return ((SessionImplementor) ftDelegate).isOpen();
+ return ((SessionImplementor) delegate).isOpen();
}
public boolean isConnected()
{
- return ((SessionImplementor) ftDelegate).isConnected();
+ return ((SessionImplementor) delegate).isConnected();
}
public FlushMode getFlushMode()
{
- return ((SessionImplementor) ftDelegate).getFlushMode();
+ return ((SessionImplementor) delegate).getFlushMode();
}
public void setFlushMode(FlushMode paramFlushMode)
{
- ((SessionImplementor) ftDelegate).setFlushMode(paramFlushMode);
+ ((SessionImplementor) delegate).setFlushMode(paramFlushMode);
}
public Connection connection()
{
- return ((SessionImplementor) ftDelegate).connection();
+ return ((SessionImplementor) delegate).connection();
}
public void flush()
{
- ((SessionImplementor) ftDelegate).flush();
+ ((SessionImplementor) delegate).flush();
}
public Query getNamedQuery(String paramString)
{
- return ((SessionImplementor) ftDelegate).getNamedQuery(paramString);
+ return ((SessionImplementor) delegate).getNamedQuery(paramString);
}
public Query getNamedSQLQuery(String paramString)
{
- return ((SessionImplementor) ftDelegate).getNamedSQLQuery(paramString);
+ return ((SessionImplementor) delegate).getNamedSQLQuery(paramString);
}
public boolean isEventSource()
{
- return ((SessionImplementor) ftDelegate).isEventSource();
+ return ((SessionImplementor) delegate).isEventSource();
}
public void afterScrollOperation()
{
- ((SessionImplementor) ftDelegate).afterScrollOperation();
+ ((SessionImplementor) delegate).afterScrollOperation();
}
public String getFetchProfile()
{
- return ((SessionImplementor) ftDelegate).getFetchProfile();
+ return ((SessionImplementor) delegate).getFetchProfile();
}
public void setFetchProfile(String paramString)
{
- ((SessionImplementor) ftDelegate).setFetchProfile(paramString);
+ ((SessionImplementor) delegate).setFetchProfile(paramString);
}
public JDBCContext getJDBCContext()
{
- return ((SessionImplementor) ftDelegate).getJDBCContext();
+ return ((SessionImplementor) delegate).getJDBCContext();
}
public boolean isClosed()
{
- return ((SessionImplementor) ftDelegate).isClosed();
+ return ((SessionImplementor) delegate).isClosed();
}
public Session getSession(EntityMode paramEntityMode)
{
- return ftDelegate.getSession(paramEntityMode);
+ return delegate.getSession(paramEntityMode);
}
public SessionFactory getSessionFactory()
{
- return ftDelegate.getSessionFactory();
+ return delegate.getSessionFactory();
}
public Connection close() throws HibernateException
{
- return ftDelegate.close();
+ return delegate.close();
}
public void cancelQuery() throws HibernateException
{
- ftDelegate.cancelQuery();
+ delegate.cancelQuery();
}
public boolean isDirty() throws HibernateException
{
- return ftDelegate.isDirty();
+ return delegate.isDirty();
}
public boolean isDefaultReadOnly()
{
- return ((HibernateSessionInvocationHandler) ftDelegate).isDefaultReadOnly();
+ return ((HibernateSessionInvocationHandler) delegate).isDefaultReadOnly();
}
public void setDefaultReadOnly(boolean paramBoolean)
{
- ((HibernateSessionInvocationHandler) ftDelegate).setDefaultReadOnly(paramBoolean);
+ ((HibernateSessionInvocationHandler) delegate).setDefaultReadOnly(paramBoolean);
}
public Serializable getIdentifier(Object paramObject) throws HibernateException
{
- return ftDelegate.getIdentifier(paramObject);
+ return delegate.getIdentifier(paramObject);
}
public boolean contains(Object paramObject)
{
- return ftDelegate.contains(paramObject);
+ return delegate.contains(paramObject);
}
public void evict(Object paramObject) throws HibernateException
{
- ftDelegate.evict(paramObject);
+ delegate.evict(paramObject);
}
public Object load(Class paramClass, Serializable paramSerializable, LockMode paramLockMode) throws HibernateException
{
- return ftDelegate.load(paramClass, paramSerializable, paramLockMode);
+ return delegate.load(paramClass, paramSerializable, paramLockMode);
}
public Object load(String paramString, Serializable paramSerializable, LockMode paramLockMode) throws HibernateException
{
- return ftDelegate.load(paramString, paramSerializable, paramLockMode);
+ return delegate.load(paramString, paramSerializable, paramLockMode);
}
public Object load(Class paramClass, Serializable paramSerializable) throws HibernateException
{
- return ftDelegate.load(paramClass, paramSerializable);
+ return delegate.load(paramClass, paramSerializable);
}
public Object load(String paramString, Serializable paramSerializable) throws HibernateException
{
- return ftDelegate.load(paramString, paramSerializable);
+ return delegate.load(paramString, paramSerializable);
}
public void load(Object paramObject, Serializable paramSerializable) throws HibernateException
{
- ftDelegate.load(paramObject, paramSerializable);
+ delegate.load(paramObject, paramSerializable);
}
public void replicate(Object paramObject, ReplicationMode paramReplicationMode) throws HibernateException
{
- ftDelegate.replicate(paramObject, paramReplicationMode);
+ delegate.replicate(paramObject, paramReplicationMode);
}
public void replicate(String paramString, Object paramObject, ReplicationMode paramReplicationMode) throws HibernateException
{
- ftDelegate.replicate(paramString, paramObject, paramReplicationMode);
+ delegate.replicate(paramString, paramObject, paramReplicationMode);
}
public Serializable save(Object paramObject) throws HibernateException
{
- return ftDelegate.save(paramObject);
+ return delegate.save(paramObject);
}
public Serializable save(String paramString, Object paramObject) throws HibernateException
{
- return ftDelegate.save(paramString, paramObject);
+ return delegate.save(paramString, paramObject);
}
public void saveOrUpdate(Object paramObject) throws HibernateException
{
- ftDelegate.saveOrUpdate(paramObject);
+ delegate.saveOrUpdate(paramObject);
}
public void saveOrUpdate(String paramString, Object paramObject) throws HibernateException
{
- ftDelegate.saveOrUpdate(paramString, paramObject);
+ delegate.saveOrUpdate(paramString, paramObject);
}
public void update(Object paramObject) throws HibernateException
{
- ftDelegate.update(paramObject);
+ delegate.update(paramObject);
}
public void update(String paramString, Object paramObject) throws HibernateException
{
- ftDelegate.update(paramString, paramObject);
+ delegate.update(paramString, paramObject);
}
public Object merge(Object paramObject) throws HibernateException
{
- return ftDelegate.merge(paramObject);
+ return delegate.merge(paramObject);
}
public Object merge(String paramString, Object paramObject) throws HibernateException
{
- return ftDelegate.merge(paramString, paramObject);
+ return delegate.merge(paramString, paramObject);
}
public void persist(Object paramObject) throws HibernateException
{
- ftDelegate.persist(paramObject);
+ delegate.persist(paramObject);
}
public void persist(String paramString, Object paramObject) throws HibernateException
{
- ftDelegate.persist(paramString, paramObject);
+ delegate.persist(paramString, paramObject);
}
public void delete(Object paramObject) throws HibernateException
{
- ftDelegate.delete(paramObject);
+ delegate.delete(paramObject);
}
public void delete(String paramString, Object paramObject) throws HibernateException
@@ -593,168 +532,168 @@
public void lock(Object paramObject, LockMode paramLockMode) throws HibernateException
{
- ftDelegate.lock(paramObject, paramLockMode);
+ delegate.lock(paramObject, paramLockMode);
}
public void lock(String paramString, Object paramObject, LockMode paramLockMode) throws HibernateException
{
- ftDelegate.lock(paramString, paramObject, paramLockMode);
+ delegate.lock(paramString, paramObject, paramLockMode);
}
public void refresh(Object paramObject) throws HibernateException
{
- ftDelegate.refresh(paramObject);
+ delegate.refresh(paramObject);
}
public void refresh(Object paramObject, LockMode paramLockMode) throws HibernateException
{
- ftDelegate.refresh(paramObject, paramLockMode);
+ delegate.refresh(paramObject, paramLockMode);
}
public LockMode getCurrentLockMode(Object paramObject) throws HibernateException
{
- return ftDelegate.getCurrentLockMode(paramObject);
+ return delegate.getCurrentLockMode(paramObject);
}
public Transaction beginTransaction() throws HibernateException
{
- return ftDelegate.beginTransaction();
+ return delegate.beginTransaction();
}
public Transaction getTransaction()
{
- return ftDelegate.getTransaction();
+ return delegate.getTransaction();
}
public Criteria createCriteria(Class paramClass)
{
- return ftDelegate.createCriteria(paramClass);
+ return delegate.createCriteria(paramClass);
}
public Criteria createCriteria(Class paramClass, String paramString)
{
- return ftDelegate.createCriteria(paramClass, paramString);
+ return delegate.createCriteria(paramClass, paramString);
}
public Criteria createCriteria(String paramString)
{
- return ftDelegate.createCriteria(paramString);
+ return delegate.createCriteria(paramString);
}
public Criteria createCriteria(String paramString1, String paramString2)
{
- return ftDelegate.createCriteria(paramString1, paramString2);
+ return delegate.createCriteria(paramString1, paramString2);
}
public Query createQuery(String paramString) throws HibernateException
{
- return ftDelegate.createQuery(paramString);
+ return delegate.createQuery(paramString);
}
public SQLQuery createSQLQuery(String paramString) throws HibernateException
{
- return ftDelegate.createSQLQuery(paramString);
+ return delegate.createSQLQuery(paramString);
}
public Query createFilter(Object paramObject, String paramString) throws HibernateException
{
- return ftDelegate.createFilter(paramObject, paramString);
+ return delegate.createFilter(paramObject, paramString);
}
public void clear()
{
- ftDelegate.clear();
+ delegate.clear();
}
public Object get(Class paramClass, Serializable paramSerializable) throws HibernateException
{
- return ftDelegate.get(paramClass, paramSerializable);
+ return delegate.get(paramClass, paramSerializable);
}
public Object get(Class paramClass, Serializable paramSerializable, LockMode paramLockMode) throws HibernateException
{
- return ftDelegate.get(paramClass, paramSerializable, paramLockMode);
+ return delegate.get(paramClass, paramSerializable, paramLockMode);
}
public Object get(String paramString, Serializable paramSerializable) throws HibernateException
{
- return ftDelegate.get(paramString, paramSerializable);
+ return delegate.get(paramString, paramSerializable);
}
public Object get(String paramString, Serializable paramSerializable, LockMode paramLockMode) throws HibernateException
{
- return ftDelegate.get(paramString, paramSerializable, paramLockMode);
+ return delegate.get(paramString, paramSerializable, paramLockMode);
}
public String getEntityName(Object paramObject) throws HibernateException
{
- return ftDelegate.getEntityName(paramObject);
+ return delegate.getEntityName(paramObject);
}
public Filter enableFilter(String paramString)
{
- return ftDelegate.enableFilter(paramString);
+ return delegate.enableFilter(paramString);
}
public Filter getEnabledFilter(String paramString)
{
- return ftDelegate.getEnabledFilter(paramString);
+ return delegate.getEnabledFilter(paramString);
}
public void disableFilter(String paramString)
{
- ftDelegate.disableFilter(paramString);
+ delegate.disableFilter(paramString);
}
public SessionStatistics getStatistics()
{
- return ftDelegate.getStatistics();
+ return delegate.getStatistics();
}
public boolean isReadOnly(Object paramObject)
{
- return ((HibernateSessionInvocationHandler) ftDelegate).isReadOnly(paramObject);
+ return ((HibernateSessionInvocationHandler) delegate).isReadOnly(paramObject);
}
public void setReadOnly(Object paramObject, boolean paramBoolean)
{
- ftDelegate.setReadOnly(paramObject, paramBoolean);
+ delegate.setReadOnly(paramObject, paramBoolean);
}
public void doWork(Work paramWork) throws HibernateException
{
- ftDelegate.doWork(paramWork);
+ delegate.doWork(paramWork);
}
public Connection disconnect() throws HibernateException
{
- return ftDelegate.disconnect();
+ return delegate.disconnect();
}
@SuppressWarnings("deprecation")
public void reconnect() throws HibernateException
{
- ftDelegate.reconnect();
+ delegate.reconnect();
}
public void reconnect(Connection paramConnection) throws HibernateException
{
- ftDelegate.reconnect(paramConnection);
+ delegate.reconnect(paramConnection);
}
public boolean isFetchProfileEnabled(String paramString)
{
- return ((HibernateSessionInvocationHandler) ftDelegate).isFetchProfileEnabled(paramString);
+ return ((HibernateSessionInvocationHandler) delegate).isFetchProfileEnabled(paramString);
}
public void enableFetchProfile(String paramString)
{
- ((HibernateSessionInvocationHandler) ftDelegate).enableFetchProfile(paramString);
+ ((HibernateSessionInvocationHandler) delegate).enableFetchProfile(paramString);
}
public void disableFetchProfile(String paramString)
{
- ((HibernateSessionInvocationHandler) ftDelegate).disableFetchProfile(paramString);
+ ((HibernateSessionInvocationHandler) delegate).disableFetchProfile(paramString);
}
public ActionQueue getActionQueue()
More information about the seam-commits
mailing list