Hibernate/hibernate-orm
1
0
Fork 0
mirror of https://github.com/hibernate/hibernate-orm synced 2025-02-16 16:15:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

HHH-2704 : migrate to maven (testsuite)

Browse Source 
HHH-2696 : migrate to slf4j

git-svn-id: https://svn.jboss.org/repos/hibernate/core/trunk@12891 1b8cb986-b30d-0410-93ca-fae66ebed9b2
This commit is contained in:
Steve Ebersole 2007-08-03 04:09:17 +00:00
parent 6472dac702
commit f0755725c9
213 changed files with 803 additions and 806 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
cache-ehcache/src/main/java/org/hibernate/cache/EhCache.java vendored
View File

@ -16,15 +16,14 @@
*/
package org.hibernate.cache;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* EHCache plugin for Hibernate
@ -39,7 +38,7 @@
* @author Emmanuel Bernard
*/
public class EhCache implements Cache {
private static final Log log = LogFactory.getLog( EhCache.class );
private static final Logger log = LoggerFactory.getLogger( EhCache.class );
private static final int SIXTY_THOUSAND_MS = 60000;

6
cache-ehcache/src/main/java/org/hibernate/cache/EhCacheProvider.java vendored
View File

@ -20,8 +20,8 @@
import java.net.URL;
import net.sf.ehcache.CacheManager;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cfg.Environment;
import org.hibernate.util.StringHelper;
import org.hibernate.util.ConfigHelper;
@ -62,7 +62,7 @@
*/
public class EhCacheProvider implements CacheProvider {
private static final Log log = LogFactory.getLog(EhCacheProvider.class);
private static final Logger log = LoggerFactory.getLogger(EhCacheProvider.class);
private CacheManager manager;

6
cache-jbosscache/src/main/java/org/hibernate/cache/OptimisticTreeCache.java vendored
View File

@ -8,8 +8,8 @@
import java.util.Comparator;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.optimistic.DataVersion;
import org.jboss.cache.config.Option;
@ -27,7 +27,7 @@ public class OptimisticTreeCache implements OptimisticCache, TransactionAwareCac
// todo : eventually merge this with TreeCache and just add optional opt-lock support there.
private static final Log log = LogFactory.getLog( OptimisticTreeCache.class);
private static final Logger log = LoggerFactory.getLogger( OptimisticTreeCache.class);
private static final String ITEM = "item";

6
cache-jbosscache/src/main/java/org/hibernate/cache/OptimisticTreeCacheProvider.java vendored
View File

@ -4,8 +4,8 @@
import java.util.Properties;
import javax.transaction.TransactionManager;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cfg.Environment;
import org.hibernate.transaction.TransactionManagerLookup;
import org.hibernate.transaction.TransactionManagerLookupFactory;
@ -32,7 +32,7 @@ public class OptimisticTreeCacheProvider implements CacheProvider {
public static final String DEFAULT_CONFIG = "treecache.xml";
private static final String NODE_LOCKING_SCHEME = "OPTIMISTIC";
private static final Log log = LogFactory.getLog( OptimisticTreeCacheProvider.class );
private static final Logger log = LoggerFactory.getLogger( OptimisticTreeCacheProvider.class );
private org.jboss.cache.TreeCache cache;

6
cache-jbosscache/src/main/java/org/hibernate/cache/TreeCache.java vendored
View File

@ -10,8 +10,8 @@
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.lock.TimeoutException;
@ -22,7 +22,7 @@
*/
public class TreeCache implements Cache, TransactionAwareCache {
private static final Log log = LogFactory.getLog(TreeCache.class);
private static final Logger log = LoggerFactory.getLogger(TreeCache.class);
private static final String ITEM = "item";

6
cache-jbosscache/src/main/java/org/hibernate/cache/TreeCacheProvider.java vendored
View File

@ -4,8 +4,8 @@
import java.util.Properties;
import javax.transaction.TransactionManager;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.transaction.TransactionManagerLookup;
import org.hibernate.transaction.TransactionManagerLookupFactory;
import org.hibernate.cfg.Environment;
@ -25,7 +25,7 @@ public class TreeCacheProvider implements CacheProvider {
public static final String CONFIG_RESOURCE = "hibernate.cache.tree_cache.config";
public static final String DEFAULT_CONFIG = "treecache.xml";
private static final Log log = LogFactory.getLog( TreeCacheProvider.class );
private static final Logger log = LoggerFactory.getLogger( TreeCacheProvider.class );
private org.jboss.cache.TreeCache cache;
private TransactionManager transactionManager;

6
cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/InvalidationCacheInstanceManager.java vendored
View File

@ -18,8 +18,8 @@
import java.util.Properties;
import javax.transaction.TransactionManager;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.jboss.cache.Cache;
import org.jboss.cache.DefaultCacheFactory;
@ -42,7 +42,7 @@ public class InvalidationCacheInstanceManager implements CacheInstanceManager {
public static final String CACHE_RESOURCE_PROP = "hibernate.cache.region.jbc2.cfg.invalidation";
public static final String DEFAULT_CACHE_RESOURCE = "treecache.xml";
private static final Log log = LogFactory.getLog( InvalidationCacheInstanceManager.class );
private static final Logger log = LoggerFactory.getLogger( InvalidationCacheInstanceManager.class );
private final Cache cache;

6
cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/collection/ReadOnlyAccess.java vendored
View File

@ -15,8 +15,8 @@
*/
package org.hibernate.cache.jbc2.collection;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.access.SoftLock;
import org.hibernate.cache.CacheException;
@ -30,7 +30,7 @@
* @author Steve Ebersole
*/
public class ReadOnlyAccess extends TransactionalAccess {
private static final Log log = LogFactory.getLog( ReadOnlyAccess.class );
private static final Logger log = LoggerFactory.getLogger( ReadOnlyAccess.class );
public ReadOnlyAccess(CollectionRegionImpl region) {
super( region );

6
cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/collection/TransactionalAccess.java vendored
View File

@ -15,8 +15,8 @@
*/
package org.hibernate.cache.jbc2.collection;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.access.CollectionRegionAccessStrategy;
import org.hibernate.cache.access.SoftLock;
@ -29,7 +29,7 @@
* @author Steve Ebersole
*/
public class TransactionalAccess implements CollectionRegionAccessStrategy {
private static final Log log = LogFactory.getLog( TransactionalAccess.class );
private static final Logger log = LoggerFactory.getLogger( TransactionalAccess.class );
private final CollectionRegionImpl region;

6
cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/ReadOnlyAccess.java vendored
View File

@ -15,8 +15,8 @@
*/
package org.hibernate.cache.jbc2.entity;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.access.SoftLock;
import org.hibernate.cache.CacheException;
@ -30,7 +30,7 @@
* @author Steve Ebersole
*/
public class ReadOnlyAccess extends TransactionalAccess {
private static final Log log = LogFactory.getLog( ReadOnlyAccess.class );
private static final Logger log = LoggerFactory.getLogger( ReadOnlyAccess.class );
public ReadOnlyAccess(EntityRegionImpl region) {
super( region );

6
cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/TransactionalAccess.java vendored
View File

@ -15,8 +15,8 @@
*/
package org.hibernate.cache.jbc2.entity;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.lock.TimeoutException;
@ -32,7 +32,7 @@
* @author Steve Ebersole
*/
public class TransactionalAccess implements EntityRegionAccessStrategy {
private static final Log log = LogFactory.getLog( TransactionalAccess.class );
private static final Logger log = LoggerFactory.getLogger( TransactionalAccess.class );
private final EntityRegionImpl region;

10
connection-c3p0/src/main/java/org/hibernate/connection/C3P0ConnectionProvider.java
View File

@ -8,8 +8,8 @@
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.mchange.v2.c3p0.DataSources;
@ -27,7 +27,7 @@
*/
public class C3P0ConnectionProvider implements ConnectionProvider {
private static final Log log = LogFactory.getLog( C3P0ConnectionProvider.class );
private static final Logger log = LoggerFactory.getLogger( C3P0ConnectionProvider.class );
//swaldman 2006-08-28: define c3p0-style configuration parameters for properties with
// hibernate-specific overrides to detect and warn about conflicting
@ -97,7 +97,7 @@ public void configure(Properties props) throws HibernateException {
}
catch ( ClassNotFoundException e ) {
String msg = "JDBC Driver class not found: " + jdbcDriverClass;
log.fatal( msg, e );
log.error( msg, e );
throw new HibernateException( msg, e );
}
}
@ -159,7 +159,7 @@ public void configure(Properties props) throws HibernateException {
ds = DataSources.pooledDataSource( unpooled, allProps );
}
catch ( Exception e ) {
log.fatal( "could not instantiate C3P0 connection pool", e );
log.error( "could not instantiate C3P0 connection pool", e );
throw new HibernateException( "Could not instantiate C3P0 connection pool", e );
}

6
connection-proxool/src/main/java/org/hibernate/connection/ProxoolConnectionProvider.java
View File

@ -12,8 +12,8 @@
import org.hibernate.util.StringHelper;
import org.hibernate.util.ConfigHelper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.ProxoolFacade;
@ -30,7 +30,7 @@ public class ProxoolConnectionProvider implements ConnectionProvider {
private static final String PROXOOL_JDBC_STEM = "proxool.";
private static final Log log = LogFactory.getLog(ProxoolConnectionProvider.class);
private static final Logger log = LoggerFactory.getLogger(ProxoolConnectionProvider.class);
private String proxoolAlias;

4
core/pom.xml
View File

@ -29,10 +29,6 @@
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</dependency>
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>

6
core/src/main/antlr/hql-sql.g
View File

@ -3,8 +3,8 @@ header
// $Id: hql-sql.g 10001 2006-06-08 21:08:04Z steve.ebersole@jboss.com $
package org.hibernate.hql.antlr;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
/**
@ -54,7 +54,7 @@ tokens
// -- Declarations --
{
private static Log log = LogFactory.getLog( HqlSqlBaseWalker.class );
private static Logger log = LoggerFactory.getLogger( HqlSqlBaseWalker.class );
private int level = 0;
private boolean inSelect = false;

6
core/src/main/antlr/sql-gen.g
View File

@ -3,8 +3,8 @@ header
// $Id: sql-gen.g 10001 2006-06-08 21:08:04Z steve.ebersole@jboss.com $
package org.hibernate.hql.antlr;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
/**
@ -28,7 +28,7 @@ options {
}
{
private static Log log = LogFactory.getLog(SqlGeneratorBase.class);
private static Logger log = LoggerFactory.getLogger(SqlGeneratorBase.class);
/** the buffer resulting SQL statement is written to */
private StringBuffer buf = new StringBuffer();

6
core/src/main/java/org/hibernate/AssertionFailure.java
View File

@ -2,8 +2,8 @@
package org.hibernate;
import org.hibernate.exception.NestableRuntimeException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Indicates failure of an assertion: a possible bug in Hibernate.
@ -13,7 +13,7 @@
public class AssertionFailure extends NestableRuntimeException {
private static final Log log = LogFactory.getLog(AssertionFailure.class);
private static final Logger log = LoggerFactory.getLogger(AssertionFailure.class);
private static final String MESSAGE = "an assertion failure occured (this may indicate a bug in Hibernate, but is more likely due to unsafe use of the session)";

4
core/src/main/java/org/hibernate/LazyInitializationException.java
View File

@ -1,7 +1,7 @@
//$Id: LazyInitializationException.java 4458 2004-08-29 09:59:17Z oneovthafew $
package org.hibernate;
import org.apache.commons.logging.LogFactory;
import org.slf4j.LoggerFactory;
/**
* Indicates access to unfetched data outside of a session context.
@ -16,7 +16,7 @@ public class LazyInitializationException extends HibernateException {
public LazyInitializationException(String msg) {
super(msg);
LogFactory.getLog(LazyInitializationException.class).error(msg, this);
LoggerFactory.getLogger( LazyInitializationException.class ).error( msg, this );
}
}

6
core/src/main/java/org/hibernate/bytecode/cglib/BytecodeProviderImpl.java
View File

@ -11,8 +11,8 @@
import net.sf.cglib.transform.TransformingClassLoader;
import net.sf.cglib.transform.impl.InterceptFieldFilter;
import net.sf.cglib.transform.impl.InterceptFieldTransformer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.bytecode.BytecodeProvider;
import org.hibernate.bytecode.ProxyFactoryFactory;
import org.hibernate.bytecode.ReflectionOptimizer;
@ -27,7 +27,7 @@
*/
public class BytecodeProviderImpl implements BytecodeProvider {
private static final Log log = LogFactory.getLog( BytecodeProviderImpl.class );
private static final Logger log = LoggerFactory.getLogger( BytecodeProviderImpl.class );
public ProxyFactoryFactory getProxyFactoryFactory() {
return new ProxyFactoryFactoryImpl();

6
core/src/main/java/org/hibernate/bytecode/cglib/CglibClassTransformer.java
View File

@ -14,8 +14,8 @@
import net.sf.cglib.transform.impl.InterceptFieldTransformer;
import net.sf.cglib.core.ClassNameReader;
import net.sf.cglib.core.DebuggingClassWriter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.bytecode.AbstractClassTransformerImpl;
import org.hibernate.bytecode.util.FieldFilter;
import org.hibernate.bytecode.util.ClassFilter;
@ -34,7 +34,7 @@
*/
public class CglibClassTransformer extends AbstractClassTransformerImpl {
private static Log log = LogFactory.getLog( CglibClassTransformer.class.getName() );
private static Logger log = LoggerFactory.getLogger( CglibClassTransformer.class.getName() );
public CglibClassTransformer(ClassFilter classFilter, FieldFilter fieldFilter) {
super( classFilter, fieldFilter );

6
core/src/main/java/org/hibernate/bytecode/javassist/BytecodeProviderImpl.java
View File

@ -2,8 +2,8 @@
import java.lang.reflect.Modifier;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.bytecode.BytecodeProvider;
import org.hibernate.bytecode.ClassTransformer;
import org.hibernate.bytecode.ProxyFactoryFactory;
@ -19,7 +19,7 @@
*/
public class BytecodeProviderImpl implements BytecodeProvider {
private static final Log log = LogFactory.getLog( BytecodeProviderImpl.class );
private static final Logger log = LoggerFactory.getLogger( BytecodeProviderImpl.class );
public ProxyFactoryFactory getProxyFactoryFactory() {
return new ProxyFactoryFactoryImpl();

6
core/src/main/java/org/hibernate/bytecode/javassist/JavassistClassTransformer.java
View File

@ -9,8 +9,8 @@
import java.security.ProtectionDomain;
import javassist.bytecode.ClassFile;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.bytecode.AbstractClassTransformerImpl;
import org.hibernate.bytecode.util.ClassFilter;
@ -24,7 +24,7 @@
*/
public class JavassistClassTransformer extends AbstractClassTransformerImpl {
private static Log log = LogFactory.getLog( JavassistClassTransformer.class.getName() );
private static Logger log = LoggerFactory.getLogger( JavassistClassTransformer.class.getName() );
public JavassistClassTransformer(ClassFilter classFilter, org.hibernate.bytecode.util.FieldFilter fieldFilter) {
super( classFilter, fieldFilter );

6
core/src/main/java/org/hibernate/cache/AbstractJndiBoundCacheProvider.java vendored
View File

@ -7,8 +7,8 @@
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cfg.Environment;
import org.hibernate.util.NamingHelper;
import org.hibernate.util.StringHelper;
@ -21,7 +21,7 @@
*/
public abstract class AbstractJndiBoundCacheProvider implements CacheProvider {
private static final Log log = LogFactory.getLog( AbstractJndiBoundCacheProvider.class );
private static final Logger log = LoggerFactory.getLogger( AbstractJndiBoundCacheProvider.class );
private Object cache;
protected void prepare(Properties properties) {

6
core/src/main/java/org/hibernate/cache/NonstrictReadWriteCache.java vendored
View File

@ -3,8 +3,8 @@
import java.util.Comparator;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.access.SoftLock;
@ -22,7 +22,7 @@ public class NonstrictReadWriteCache implements CacheConcurrencyStrategy {
private Cache cache;
private static final Log log = LogFactory.getLog( NonstrictReadWriteCache.class );
private static final Logger log = LoggerFactory.getLogger( NonstrictReadWriteCache.class );
public NonstrictReadWriteCache() {
}

6
core/src/main/java/org/hibernate/cache/ReadOnlyCache.java vendored
View File

@ -3,8 +3,8 @@
import java.util.Comparator;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.access.SoftLock;
@ -15,7 +15,7 @@
public class ReadOnlyCache implements CacheConcurrencyStrategy {
private Cache cache;
private static final Log log = LogFactory.getLog(ReadOnlyCache.class);
private static final Logger log = LoggerFactory.getLogger(ReadOnlyCache.class);
public ReadOnlyCache() {}

6
core/src/main/java/org/hibernate/cache/ReadWriteCache.java vendored
View File

@ -4,8 +4,8 @@
import java.io.Serializable;
import java.util.Comparator;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.access.SoftLock;
@ -27,7 +27,7 @@
*/
public class ReadWriteCache implements CacheConcurrencyStrategy {
private static final Log log = LogFactory.getLog(ReadWriteCache.class);
private static final Logger log = LoggerFactory.getLogger(ReadWriteCache.class);
private Cache cache;
private int nextLockId;

6
core/src/main/java/org/hibernate/cache/StandardQueryCache.java vendored
View File

@ -7,8 +7,8 @@
import java.util.Properties;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.UnresolvableObjectException;
@ -28,7 +28,7 @@
*/
public class StandardQueryCache implements QueryCache {
private static final Log log = LogFactory.getLog( StandardQueryCache.class );
private static final Logger log = LoggerFactory.getLogger( StandardQueryCache.class );
private QueryResultsRegion cacheRegion;
private UpdateTimestampsCache updateTimestampsCache;

6
core/src/main/java/org/hibernate/cache/TransactionalCache.java vendored
View File

@ -3,8 +3,8 @@
import java.util.Comparator;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.access.SoftLock;
@ -18,7 +18,7 @@
*/
public class TransactionalCache implements CacheConcurrencyStrategy {
private static final Log log = LogFactory.getLog( TransactionalCache.class );
private static final Logger log = LoggerFactory.getLogger( TransactionalCache.class );
private Cache cache;

6
core/src/main/java/org/hibernate/cache/UpdateTimestampsCache.java vendored
View File

@ -6,8 +6,8 @@
import java.util.Properties;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.cfg.Settings;
@ -24,7 +24,7 @@
*/
public class UpdateTimestampsCache {
public static final String REGION_NAME = UpdateTimestampsCache.class.getName();
private static final Log log = LogFactory.getLog( UpdateTimestampsCache.class );
private static final Logger log = LoggerFactory.getLogger( UpdateTimestampsCache.class );
private final TimestampsRegion region;

6
core/src/main/java/org/hibernate/cache/impl/bridge/CollectionRegionAdapter.java vendored
View File

@ -1,7 +1,7 @@
package org.hibernate.cache.impl.bridge;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.CollectionRegion;
import org.hibernate.cache.Cache;
@ -23,7 +23,7 @@
* @author Steve Ebersole
*/
public class CollectionRegionAdapter extends BaseTransactionalDataRegionAdapter implements CollectionRegion {
private static final Log log = LogFactory.getLog( CollectionRegionAdapter.class );
private static final Logger log = LoggerFactory.getLogger( CollectionRegionAdapter.class );
public CollectionRegionAdapter(Cache underlyingCache, Settings settings, CacheDataDescription metadata) {
super( underlyingCache, settings, metadata );

6
core/src/main/java/org/hibernate/cache/impl/bridge/EntityRegionAdapter.java vendored
View File

@ -1,7 +1,7 @@
package org.hibernate.cache.impl.bridge;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.EntityRegion;
import org.hibernate.cache.Cache;
@ -23,7 +23,7 @@
* @author Steve Ebersole
*/
public class EntityRegionAdapter extends BaseTransactionalDataRegionAdapter implements EntityRegion {
private static final Log log = LogFactory.getLog( EntityRegionAdapter.class );
private static final Logger log = LoggerFactory.getLogger( EntityRegionAdapter.class );
public EntityRegionAdapter(Cache underlyingCache, Settings settings, CacheDataDescription metadata) {
super( underlyingCache, settings, metadata );

6
core/src/main/java/org/hibernate/cache/impl/bridge/RegionFactoryCacheProviderBridge.java vendored
View File

@ -2,8 +2,8 @@
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.cache.RegionFactory;
import org.hibernate.cache.CacheProvider;
@ -27,7 +27,7 @@
*/
public class RegionFactoryCacheProviderBridge implements RegionFactory {
public static final String DEF_PROVIDER = NoCacheProvider.class.getName();
private static final Log log = LogFactory.getLog( RegionFactoryCacheProviderBridge.class );
private static final Logger log = LoggerFactory.getLogger( RegionFactoryCacheProviderBridge.class );
private CacheProvider cacheProvider;
private Settings settings;

6
core/src/main/java/org/hibernate/cfg/CollectionSecondPass.java
View File

@ -5,8 +5,8 @@
import java.util.Iterator;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.MappingException;
import org.hibernate.mapping.Collection;
import org.hibernate.mapping.IndexedCollection;
@ -20,7 +20,7 @@
* @author Emmanuel Bernard
*/
public abstract class CollectionSecondPass implements SecondPass {
private static Log log = LogFactory.getLog( CollectionSecondPass.class );
private static Logger log = LoggerFactory.getLogger( CollectionSecondPass.class );
Mappings mappings;
Collection collection;
private Map localInheritedMetas;

6
core/src/main/java/org/hibernate/cfg/Configuration.java
View File

@ -26,8 +26,8 @@
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.dom4j.Attribute;
import org.dom4j.DocumentException;
import org.dom4j.Element;
@ -117,7 +117,7 @@
*/
public class Configuration implements Serializable {
private static Log log = LogFactory.getLog( Configuration.class );
private static Logger log = LoggerFactory.getLogger( Configuration.class );
protected Map classes;
protected Map imports;

6
core/src/main/java/org/hibernate/cfg/Environment.java
View File

@ -11,8 +11,8 @@
import java.util.Map;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.bytecode.BytecodeProvider;
@ -490,7 +490,7 @@ public final class Environment {
private static final Map OBSOLETE_PROPERTIES = new HashMap();
private static final Map RENAMED_PROPERTIES = new HashMap();
private static final Log log = LogFactory.getLog(Environment.class);
private static final Logger log = LoggerFactory.getLogger(Environment.class);
/**
* Issues warnings to the user when any obsolete property names are used.

6
core/src/main/java/org/hibernate/cfg/HbmBinder.java
View File

@ -9,8 +9,8 @@
import java.util.Properties;
import java.util.StringTokenizer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
@ -85,7 +85,7 @@
*/
public final class HbmBinder {
private static final Log log = LogFactory.getLog( HbmBinder.class );
private static final Logger log = LoggerFactory.getLogger( HbmBinder.class );
/**
* Private constructor to disallow instantiation.

6
core/src/main/java/org/hibernate/cfg/Mappings.java
View File

@ -8,8 +8,8 @@
import java.util.Properties;
import java.util.HashMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.DuplicateMappingException;
import org.hibernate.MappingException;
import org.hibernate.engine.FilterDefinition;
@ -33,7 +33,7 @@
*/
public class Mappings implements Serializable {
private static final Log log = LogFactory.getLog(Mappings.class);
private static final Logger log = LoggerFactory.getLogger(Mappings.class);
protected final Map classes;
protected final Map collections;

6
core/src/main/java/org/hibernate/cfg/NamedSQLQuerySecondPass.java
View File

@ -11,14 +11,14 @@
import org.hibernate.engine.ResultSetMappingDefinition;
import org.dom4j.Attribute;
import org.dom4j.Element;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Emmanuel Bernard
*/
public class NamedSQLQuerySecondPass extends ResultSetMappingBinder implements QuerySecondPass {
private static Log log = LogFactory.getLog( NamedSQLQuerySecondPass.class);
private static Logger log = LoggerFactory.getLogger( NamedSQLQuerySecondPass.class);
private Element queryElem;
private String path;
private Mappings mappings;

6
core/src/main/java/org/hibernate/cfg/SettingsFactory.java
View File

@ -10,8 +10,8 @@
import java.util.Map;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.ConnectionReleaseMode;
import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
@ -46,7 +46,7 @@
public class SettingsFactory implements Serializable {
public static final String DEF_CACHE_REG_FACTORY = NoCachingRegionFactory.class.getName();
private static final Log log = LogFactory.getLog(SettingsFactory.class);
private static final Logger log = LoggerFactory.getLogger(SettingsFactory.class);
protected SettingsFactory() {
}

6
core/src/main/java/org/hibernate/collection/PersistentArrayHolder.java
View File

@ -9,8 +9,8 @@
import java.util.Collection;
import java.util.Iterator;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
import org.hibernate.loader.CollectionAliases;
@ -28,7 +28,7 @@
public class PersistentArrayHolder extends AbstractPersistentCollection {
protected Object array;
private static final Log log = LogFactory.getLog(PersistentArrayHolder.class);
private static final Logger log = LoggerFactory.getLogger(PersistentArrayHolder.class);
//just to help out during the load (ugly, i know)
private transient Class elementClass;

22
core/src/main/java/org/hibernate/connection/ConnectionProviderFactory.java
View File

@ -13,8 +13,8 @@
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.cfg.Environment;
@ -34,11 +34,11 @@
public final class ConnectionProviderFactory {
private static final Log log = LogFactory.getLog(ConnectionProviderFactory.class);
private static final Logger log = LoggerFactory.getLogger(ConnectionProviderFactory.class);
/**
* Instantiate a <tt>ConnectionProvider</tt> using <tt>System</tt> properties.
* @return ConnectionProvider
* @return The created connection provider.
* @throws HibernateException
*/
public static ConnectionProvider newConnectionProvider() throws HibernateException {
@ -57,11 +57,11 @@ public static ConnectionProvider newConnectionProvider(Properties properties) th
}
/**
* Instantiate a <tt>ConnectionProvider</tt> using given properties.
* Method newConnectionProvider.
* @param properties hibernate <tt>SessionFactory</tt> properties
* @Param connectionProviderInjectionData object to be injected in the conenction provided
* @return ConnectionProvider
* Create a connection provider based on the given information.
*
* @param properties Properties being used to build the {@link org.hibernate.SessionFactory}.
* @param connectionProviderInjectionData Soemthing to be injected in the conenction provided
* @return The created connection provider
* @throws HibernateException
*/
public static ConnectionProvider newConnectionProvider(Properties properties, Map connectionProviderInjectionData) throws HibernateException {
@ -72,8 +72,8 @@ public static ConnectionProvider newConnectionProvider(Properties properties, Ma
log.info("Initializing connection provider: " + providerClass);
connections = (ConnectionProvider) ReflectHelper.classForName(providerClass).newInstance();
}
catch (Exception e) {
log.fatal("Could not instantiate connection provider", e);
catch ( Exception e ) {
log.error( "Could not instantiate connection provider", e );
throw new HibernateException("Could not instantiate connection provider: " + providerClass);
}
}

26
core/src/main/java/org/hibernate/connection/DatasourceConnectionProvider.java
View File

@ -11,8 +11,8 @@
import org.hibernate.cfg.Environment;
import org.hibernate.util.NamingHelper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A connection provider that uses a <tt>DataSource</tt> registered with JNDI.
@ -26,7 +26,7 @@ public class DatasourceConnectionProvider implements ConnectionProvider {
private String user;
private String pass;
private static final Log log = LogFactory.getLog(DatasourceConnectionProvider.class);
private static final Logger log = LoggerFactory.getLogger(DatasourceConnectionProvider.class);
public DataSource getDataSource() {
return ds;
@ -38,24 +38,24 @@ public void setDataSource(DataSource ds) {
public void configure(Properties props) throws HibernateException {
String jndiName = props.getProperty(Environment.DATASOURCE);
if (jndiName==null) {
String jndiName = props.getProperty( Environment.DATASOURCE );
if ( jndiName == null ) {
String msg = "datasource JNDI name was not specified by property " + Environment.DATASOURCE;
log.fatal(msg);
throw new HibernateException(msg);
log.error( msg );
throw new HibernateException( msg );
}
user = props.getProperty(Environment.USER);
pass = props.getProperty(Environment.PASS);
user = props.getProperty( Environment.USER );
pass = props.getProperty( Environment.PASS );
try {
ds = (DataSource) NamingHelper.getInitialContext(props).lookup(jndiName);
ds = ( DataSource ) NamingHelper.getInitialContext( props ).lookup( jndiName );
}
catch (Exception e) {
log.fatal( "Could not find datasource: " + jndiName, e );
catch ( Exception e ) {
log.error( "Could not find datasource: " + jndiName, e );
throw new HibernateException( "Could not find datasource", e );
}
if (ds==null) {
if ( ds == null ) {
throw new HibernateException( "Could not find datasource: " + jndiName );
}
log.info( "Using datasource: " + jndiName );

18
core/src/main/java/org/hibernate/connection/DriverManagerConnectionProvider.java
View File

@ -8,8 +8,8 @@
import java.util.Iterator;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.cfg.Environment;
import org.hibernate.util.PropertiesHelper;
@ -31,7 +31,7 @@ public class DriverManagerConnectionProvider implements ConnectionProvider {
private int checkedOut = 0;
private boolean autocommit;
private static final Log log = LogFactory.getLog(DriverManagerConnectionProvider.class);
private static final Logger log = LoggerFactory.getLogger(DriverManagerConnectionProvider.class);
public void configure(Properties props) throws HibernateException {
@ -62,20 +62,20 @@ public void configure(Properties props) throws HibernateException {
}
catch (ClassNotFoundException e) {
String msg = "JDBC Driver class not found: " + driverClass;
log.fatal(msg, e);
log.error( msg, e );
throw new HibernateException(msg, e);
}
}
}
url = props.getProperty(Environment.URL);
if (url==null) {
url = props.getProperty( Environment.URL );
if ( url == null ) {
String msg = "JDBC URL was not specified by property " + Environment.URL;
log.fatal(msg);
throw new HibernateException(msg);
log.error( msg );
throw new HibernateException( msg );
}
connectionProps = ConnectionProviderFactory.getConnectionProperties(props);
connectionProps = ConnectionProviderFactory.getConnectionProperties( props );
log.info( "using driver: " + driverClass + " at URL: " + url );
// if debug level is enabled, then log the password, otherwise mask it

5
core/src/main/java/org/hibernate/connection/UserSuppliedConnectionProvider.java
View File

@ -4,7 +4,7 @@
import java.sql.Connection;
import java.util.Properties;
import org.apache.commons.logging.LogFactory;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
/**
@ -20,7 +20,8 @@ public class UserSuppliedConnectionProvider implements ConnectionProvider {
* @see org.hibernate.connection.ConnectionProvider#configure(Properties)
*/
public void configure(Properties props) throws HibernateException {
LogFactory.getLog(UserSuppliedConnectionProvider.class).warn("No connection properties specified - the user must supply JDBC connections");
LoggerFactory.getLogger( UserSuppliedConnectionProvider.class )
.warn( "No connection properties specified - the user must supply JDBC connections" );
}
/**

6
core/src/main/java/org/hibernate/context/JTASessionContext.java
View File

@ -5,8 +5,8 @@
import org.hibernate.classic.Session;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.util.JTAHelper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
@ -39,7 +39,7 @@
*/
public class JTASessionContext implements CurrentSessionContext {
private static final Log log = LogFactory.getLog( JTASessionContext.class );
private static final Logger log = LoggerFactory.getLogger( JTASessionContext.class );
protected final SessionFactoryImplementor factory;
private transient Map currentSessionMap = new Hashtable();

6
core/src/main/java/org/hibernate/context/ThreadLocalSessionContext.java
View File

@ -12,8 +12,8 @@
import java.util.Map;
import javax.transaction.Synchronization;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.ConnectionReleaseMode;
import org.hibernate.HibernateException;
import org.hibernate.SessionFactory;
@ -48,7 +48,7 @@
*/
public class ThreadLocalSessionContext implements CurrentSessionContext {
private static final Log log = LogFactory.getLog( ThreadLocalSessionContext.class );
private static final Logger log = LoggerFactory.getLogger( ThreadLocalSessionContext.class );
private static final Class[] SESS_PROXY_INTERFACES = new Class[] {
org.hibernate.classic.Session.class,
org.hibernate.engine.SessionImplementor.class,

6
core/src/main/java/org/hibernate/dialect/Dialect.java
View File

@ -11,8 +11,8 @@
import java.util.Properties;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
@ -56,7 +56,7 @@
*/
public abstract class Dialect {
private static final Log log = LogFactory.getLog( Dialect.class );
private static final Logger log = LoggerFactory.getLogger( Dialect.class );
public static final String DEFAULT_BATCH_SIZE = "15";
public static final String NO_BATCH = "0";

6
core/src/main/java/org/hibernate/dialect/HSQLDialect.java
View File

@ -21,8 +21,8 @@
import org.hibernate.exception.JDBCExceptionHelper;
import org.hibernate.exception.TemplatedViolatedConstraintNameExtracter;
import org.hibernate.exception.ViolatedConstraintNameExtracter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* An SQL dialect compatible with HSQLDB (Hypersonic SQL).
@ -33,7 +33,7 @@
*/
public class HSQLDialect extends Dialect {
private static final Log log = LogFactory.getLog( HSQLDialect.class );
private static final Logger log = LoggerFactory.getLogger( HSQLDialect.class );
private boolean schemaSupport;

6
core/src/main/java/org/hibernate/dialect/Oracle9Dialect.java
View File

@ -6,8 +6,8 @@
import java.sql.SQLException;
import java.sql.Types;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
@ -30,7 +30,7 @@
*/
public class Oracle9Dialect extends Dialect {
private static final Log log = LogFactory.getLog( Oracle9Dialect.class );
private static final Logger log = LoggerFactory.getLogger( Oracle9Dialect.class );
public Oracle9Dialect() {
super();

6
core/src/main/java/org/hibernate/dialect/OracleDialect.java
View File

@ -3,8 +3,8 @@
import java.sql.Types;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.sql.CaseFragment;
import org.hibernate.sql.DecodeCaseFragment;
@ -19,7 +19,7 @@
*/
public class OracleDialect extends Oracle9Dialect {
private static final Log log = LogFactory.getLog( OracleDialect.class );
private static final Logger log = LoggerFactory.getLogger( OracleDialect.class );
public OracleDialect() {
super();

6
core/src/main/java/org/hibernate/dialect/RDMSOS2200Dialect.java
View File

@ -24,14 +24,14 @@
import org.hibernate.persister.entity.Lockable;
import org.hibernate.sql.CaseFragment;
import org.hibernate.sql.DecodeCaseFragment;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author Ploski and Hanson
*/
public class RDMSOS2200Dialect extends Dialect {
private static Log log = LogFactory.getLog(RDMSOS2200Dialect.class);
private static Logger log = LoggerFactory.getLogger(RDMSOS2200Dialect.class);
public RDMSOS2200Dialect() {
super();

6
core/src/main/java/org/hibernate/dialect/lock/UpdateLockingStrategy.java
View File

@ -10,8 +10,8 @@
import org.hibernate.sql.Update;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.engine.SessionFactoryImplementor;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.Serializable;
import java.sql.PreparedStatement;
@ -27,7 +27,7 @@
* @author Steve Ebersole
*/
public class UpdateLockingStrategy implements LockingStrategy {
private static final Log log = LogFactory.getLog( UpdateLockingStrategy.class );
private static final Logger log = LoggerFactory.getLogger( UpdateLockingStrategy.class );
private final Lockable lockable;
private final LockMode lockMode;

6
core/src/main/java/org/hibernate/engine/ActionQueue.java
View File

@ -13,8 +13,8 @@
import org.hibernate.HibernateException;
import org.hibernate.AssertionFailure;
import org.hibernate.cache.CacheException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
@ -37,7 +37,7 @@
*/
public class ActionQueue {
private static final Log log = LogFactory.getLog( ActionQueue.class );
private static final Logger log = LoggerFactory.getLogger( ActionQueue.class );
private static final int INIT_QUEUE_LIST_SIZE = 5;
private SessionImplementor session;

6
core/src/main/java/org/hibernate/engine/Cascade.java
View File

@ -4,8 +4,8 @@
import java.util.Collection;
import java.util.Iterator;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
import org.hibernate.collection.PersistentCollection;
@ -72,7 +72,7 @@ public final class Cascade {
public static final int BEFORE_MERGE = 0;
private static final Log log = LogFactory.getLog( Cascade.class );
private static final Logger log = LoggerFactory.getLogger( Cascade.class );
private int cascadeTo;

6
core/src/main/java/org/hibernate/engine/CascadingAction.java
View File

@ -5,8 +5,8 @@
import java.util.Map;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.ReplicationMode;
@ -26,7 +26,7 @@
*/
public abstract class CascadingAction {
private static final Log log = LogFactory.getLog( CascadingAction.class );
private static final Logger log = LoggerFactory.getLogger( CascadingAction.class );
// the CascadingAction contract ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

6
core/src/main/java/org/hibernate/engine/CollectionEntry.java
View File

@ -7,8 +7,8 @@
import java.io.ObjectInputStream;
import java.util.Collection;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.AssertionFailure;
import org.hibernate.HibernateException;
import org.hibernate.MappingException;
@ -24,7 +24,7 @@
*/
public final class CollectionEntry implements Serializable {
private static final Log log = LogFactory.getLog(CollectionEntry.class);
private static final Logger log = LoggerFactory.getLogger(CollectionEntry.class);
//ATTRIBUTES MAINTAINED BETWEEN FLUSH CYCLES

6
core/src/main/java/org/hibernate/engine/Collections.java
View File

@ -1,8 +1,8 @@
//$Id: Collections.java 8694 2005-11-28 19:28:17Z steveebersole $
package org.hibernate.engine;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.AssertionFailure;
import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
@ -21,7 +21,7 @@ public final class Collections {
private Collections() {}
private static final Log log = LogFactory.getLog(Collections.class);
private static final Logger log = LoggerFactory.getLogger(Collections.class);
/**
* record the fact that this collection was dereferenced

6
core/src/main/java/org/hibernate/engine/IdentifierValue.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A strategy for determining if an identifier value is an identifier of
@ -16,7 +16,7 @@
*/
public class IdentifierValue {
private static final Log log = LogFactory.getLog(IdentifierValue.class);
private static final Logger log = LoggerFactory.getLogger(IdentifierValue.class);
private final Serializable value;

6
core/src/main/java/org/hibernate/engine/ParameterBinder.java
View File

@ -3,8 +3,8 @@
import org.hibernate.HibernateException;
import org.hibernate.type.Type;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.sql.PreparedStatement;
import java.sql.SQLException;
@ -22,7 +22,7 @@
*/
public class ParameterBinder {
private static final Log log = LogFactory.getLog( ParameterBinder.class );
private static final Logger log = LoggerFactory.getLogger( ParameterBinder.class );
public static interface NamedParameterSource {
public int[] getNamedParameterLocations(String name);

6
core/src/main/java/org/hibernate/engine/QueryParameters.java
View File

@ -10,8 +10,8 @@
import java.util.Map;
import java.util.StringTokenizer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.QueryException;
@ -27,7 +27,7 @@
* @author Gavin King
*/
public final class QueryParameters {
private static final Log log = LogFactory.getLog(QueryParameters.class);
private static final Logger log = LoggerFactory.getLogger(QueryParameters.class);
private Type[] positionalParameterTypes;
private Object[] positionalParameterValues;

8
core/src/main/java/org/hibernate/engine/StatefulPersistenceContext.java
View File

@ -14,8 +14,8 @@
import java.util.Map;
import org.apache.commons.collections.map.ReferenceMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.AssertionFailure;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
@ -51,8 +51,8 @@ public class StatefulPersistenceContext implements PersistenceContext {
public static final Object NO_ROW = new MarkerObject( "NO_ROW" );
private static final Log log = LogFactory.getLog( StatefulPersistenceContext.class );
private static final Log PROXY_WARN_LOG = LogFactory.getLog( StatefulPersistenceContext.class.getName() + ".ProxyWarnLog" );
private static final Logger log = LoggerFactory.getLogger( StatefulPersistenceContext.class );
private static final Logger PROXY_WARN_LOG = LoggerFactory.getLogger( StatefulPersistenceContext.class.getName() + ".ProxyWarnLog" );
private static final int INIT_COLL_SIZE = 8;
private SessionImplementor session;

6
core/src/main/java/org/hibernate/engine/TwoPhaseLoad.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.AssertionFailure;
import org.hibernate.CacheMode;
import org.hibernate.HibernateException;
@ -31,7 +31,7 @@
*/
public final class TwoPhaseLoad {
private static final Log log = LogFactory.getLog(TwoPhaseLoad.class);
private static final Logger log = LoggerFactory.getLogger(TwoPhaseLoad.class);
private TwoPhaseLoad() {}

6
core/src/main/java/org/hibernate/engine/VersionValue.java
View File

@ -1,8 +1,8 @@
//$Id: VersionValue.java 7017 2005-06-05 04:31:34Z oneovthafew $
package org.hibernate.engine;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.MappingException;
import org.hibernate.id.IdentifierGeneratorFactory;
@ -16,7 +16,7 @@
*/
public class VersionValue {
private static final Log log = LogFactory.getLog(VersionValue.class);
private static final Logger log = LoggerFactory.getLogger(VersionValue.class);
private final Object value;
/**

6
core/src/main/java/org/hibernate/engine/Versioning.java
View File

@ -1,8 +1,8 @@
//$Id: Versioning.java 10857 2006-11-21 23:28:07Z steve.ebersole@jboss.com $
package org.hibernate.engine;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.persister.entity.EntityPersister;
import org.hibernate.type.VersionType;
@ -36,7 +36,7 @@ public final class Versioning {
*/
public static final int OPTIMISTIC_LOCK_DIRTY = 1;
private static final Log log = LogFactory.getLog( Versioning.class );
private static final Logger log = LoggerFactory.getLogger( Versioning.class );
/**
* Private constructor disallowing instantiation.

6
core/src/main/java/org/hibernate/engine/loading/CollectionLoadContext.java
View File

@ -8,8 +8,8 @@
import java.util.Set;
import java.util.HashSet;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.collection.PersistentCollection;
import org.hibernate.persister.collection.CollectionPersister;
@ -35,7 +35,7 @@
* @author Steve Ebersole
*/
public class CollectionLoadContext {
private static final Log log = LogFactory.getLog( CollectionLoadContext.class );
private static final Logger log = LoggerFactory.getLogger( CollectionLoadContext.class );
private final LoadContexts loadContexts;
private final ResultSet resultSet;

6
core/src/main/java/org/hibernate/engine/loading/EntityLoadContext.java
View File

@ -4,8 +4,8 @@
import java.util.List;
import java.util.ArrayList;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* {@inheritDoc}
@ -13,7 +13,7 @@
* @author Steve Ebersole
*/
public class EntityLoadContext {
private static final Log log = LogFactory.getLog( EntityLoadContext.class );
private static final Logger log = LoggerFactory.getLogger( EntityLoadContext.class );
private final LoadContexts loadContexts;
private final ResultSet resultSet;

6
core/src/main/java/org/hibernate/engine/loading/LoadContexts.java
View File

@ -7,8 +7,8 @@
import java.util.HashMap;
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.util.IdentityMap;
import org.hibernate.engine.PersistenceContext;
@ -36,7 +36,7 @@
* @author Steve Ebersole
*/
public class LoadContexts {
private static final Log log = LogFactory.getLog( LoadContexts.class );
private static final Logger log = LoggerFactory.getLogger( LoadContexts.class );
private final PersistenceContext persistenceContext;
private Map collectionLoadContexts;

6
core/src/main/java/org/hibernate/engine/query/HQLQueryPlan.java
View File

@ -17,8 +17,8 @@
import org.hibernate.engine.SessionImplementor;
import org.hibernate.engine.RowSelection;
import org.hibernate.event.EventSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.Serializable;
import java.util.Map;
@ -38,7 +38,7 @@ public class HQLQueryPlan implements Serializable {
// TODO : keep seperate notions of QT[] here for shallow/non-shallow queries...
private static final Log log = LogFactory.getLog( HQLQueryPlan.class );
private static final Logger log = LoggerFactory.getLogger( HQLQueryPlan.class );
private final String sourceQuery;
private final QueryTranslator[] translators;

6
core/src/main/java/org/hibernate/engine/query/NativeSQLQueryPlan.java
View File

@ -7,8 +7,8 @@
import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.QueryException;
import org.hibernate.engine.query.sql.NativeSQLQuerySpecification;
@ -33,7 +33,7 @@ public class NativeSQLQueryPlan implements Serializable {
private final SQLCustomQuery customQuery;
private static final Log log = LogFactory.getLog(NativeSQLQueryPlan.class);
private static final Logger log = LoggerFactory.getLogger(NativeSQLQueryPlan.class);
public NativeSQLQueryPlan(
NativeSQLQuerySpecification specification,

6
core/src/main/java/org/hibernate/engine/query/QueryPlanCache.java
View File

@ -7,8 +7,8 @@
import org.hibernate.engine.query.sql.NativeSQLQuerySpecification;
import org.hibernate.QueryException;
import org.hibernate.MappingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.Serializable;
import java.util.Map;
@ -26,7 +26,7 @@
*/
public class QueryPlanCache implements Serializable {
private static final Log log = LogFactory.getLog( QueryPlanCache.class );
private static final Logger log = LoggerFactory.getLogger( QueryPlanCache.class );
private SessionFactoryImplementor factory;

6
core/src/main/java/org/hibernate/engine/transaction/Isolater.java
View File

@ -5,8 +5,8 @@
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.exception.JDBCExceptionHelper;
@ -24,7 +24,7 @@
*/
public class Isolater {
private static final Log log = LogFactory.getLog( Isolater.class );
private static final Logger log = LoggerFactory.getLogger( Isolater.class );
/**
* Ensures that all processing actually performed by the given work will

6
core/src/main/java/org/hibernate/event/def/AbstractFlushingEventListener.java
View File

@ -6,8 +6,8 @@
import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.action.CollectionRecreateAction;
import org.hibernate.action.CollectionRemoveAction;
@ -39,7 +39,7 @@
*/
public abstract class AbstractFlushingEventListener implements Serializable {
private static final Log log = LogFactory.getLog(AbstractFlushingEventListener.class);
private static final Logger log = LoggerFactory.getLogger(AbstractFlushingEventListener.class);
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Pre-flushing section

6
core/src/main/java/org/hibernate/event/def/AbstractLockUpgradeEventListener.java
View File

@ -1,8 +1,8 @@
//$Id: AbstractLockUpgradeEventListener.java 11398 2007-04-10 14:54:07Z steve.ebersole@jboss.com $
package org.hibernate.event.def;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.LockMode;
import org.hibernate.ObjectDeletedException;
@ -22,7 +22,7 @@
*/
public class AbstractLockUpgradeEventListener extends AbstractReassociateEventListener {
private static final Log log = LogFactory.getLog(AbstractLockUpgradeEventListener.class);
private static final Logger log = LoggerFactory.getLogger(AbstractLockUpgradeEventListener.class);
/**
* Performs a pessimistic lock upgrade on a given entity, if needed.

6
core/src/main/java/org/hibernate/event/def/AbstractReassociateEventListener.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.LockMode;
import org.hibernate.engine.EntityEntry;
@ -25,7 +25,7 @@
*/
public class AbstractReassociateEventListener implements Serializable {
private static final Log log = LogFactory.getLog( AbstractReassociateEventListener.class );
private static final Logger log = LoggerFactory.getLogger( AbstractReassociateEventListener.class );
/**
* Associates a given entity (either transient or associated with another session) to

6
core/src/main/java/org/hibernate/event/def/AbstractSaveEventListener.java
View File

@ -4,8 +4,8 @@
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.LockMode;
import org.hibernate.NonUniqueObjectException;
@ -44,7 +44,7 @@ public abstract class AbstractSaveEventListener extends AbstractReassociateEvent
protected static final int DETACHED = 2;
protected static final int DELETED = 3;
private static final Log log = LogFactory.getLog( AbstractSaveEventListener.class );
private static final Logger log = LoggerFactory.getLogger( AbstractSaveEventListener.class );
/**
* Prepares the save call using the given requested id.

6
core/src/main/java/org/hibernate/event/def/DefaultAutoFlushEventListener.java
View File

@ -1,8 +1,8 @@
//$Id: DefaultAutoFlushEventListener.java 7785 2005-08-08 23:24:44Z oneovthafew $
package org.hibernate.event.def;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.FlushMode;
import org.hibernate.HibernateException;
import org.hibernate.event.AutoFlushEvent;
@ -17,7 +17,7 @@
*/
public class DefaultAutoFlushEventListener extends AbstractFlushingEventListener implements AutoFlushEventListener {
private static final Log log = LogFactory.getLog(DefaultAutoFlushEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultAutoFlushEventListener.class);
/** Handle the given auto-flush event.
*

6
core/src/main/java/org/hibernate/event/def/DefaultDeleteEventListener.java
View File

@ -4,8 +4,8 @@
import java.io.Serializable;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.CacheMode;
import org.hibernate.HibernateException;
@ -39,7 +39,7 @@
*/
public class DefaultDeleteEventListener implements DeleteEventListener {
private static final Log log = LogFactory.getLog( DefaultDeleteEventListener.class );
private static final Logger log = LoggerFactory.getLogger( DefaultDeleteEventListener.class );
/**
* Handle the given delete event.

6
core/src/main/java/org/hibernate/event/def/DefaultDirtyCheckEventListener.java
View File

@ -4,8 +4,8 @@
import org.hibernate.HibernateException;
import org.hibernate.event.DirtyCheckEvent;
import org.hibernate.event.DirtyCheckEventListener;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Defines the default dirty-check event listener used by hibernate for
@ -16,7 +16,7 @@
*/
public class DefaultDirtyCheckEventListener extends AbstractFlushingEventListener implements DirtyCheckEventListener {
private static final Log log = LogFactory.getLog(DefaultDirtyCheckEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultDirtyCheckEventListener.class);
/** Handle the given dirty-check event.
*

6
core/src/main/java/org/hibernate/event/def/DefaultEvictEventListener.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.engine.Cascade;
import org.hibernate.engine.CascadingAction;
@ -29,7 +29,7 @@
*/
public class DefaultEvictEventListener implements EvictEventListener {
private static final Log log = LogFactory.getLog(DefaultEvictEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultEvictEventListener.class);
/**
* Handle the given evict event.

6
core/src/main/java/org/hibernate/event/def/DefaultFlushEntityEventListener.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.AssertionFailure;
import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
@ -34,7 +34,7 @@
*/
public class DefaultFlushEntityEventListener implements FlushEntityEventListener {
private static final Log log = LogFactory.getLog(DefaultFlushEntityEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultFlushEntityEventListener.class);
/**
* make sure user didn't mangle the id

6
core/src/main/java/org/hibernate/event/def/DefaultInitializeCollectionEventListener.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.cache.CacheKey;
import org.hibernate.cache.entry.CollectionCacheEntry;
@ -23,7 +23,7 @@
*/
public class DefaultInitializeCollectionEventListener implements InitializeCollectionEventListener {
private static final Log log = LogFactory.getLog(DefaultInitializeCollectionEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultInitializeCollectionEventListener.class);
/**
* called by a collection that wants to initialize itself

6
core/src/main/java/org/hibernate/event/def/DefaultLoadEventListener.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.NonUniqueObjectException;
@ -46,7 +46,7 @@ public class DefaultLoadEventListener extends AbstractLockUpgradeEventListener i
public static final Object INCONSISTENT_RTN_CLASS_MARKER = new Object();
public static final LockMode DEFAULT_LOCK_MODE = LockMode.NONE;
private static final Log log = LogFactory.getLog(DefaultLoadEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultLoadEventListener.class);
/**

6
core/src/main/java/org/hibernate/event/def/DefaultMergeEventListener.java
View File

@ -4,8 +4,8 @@
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.AssertionFailure;
import org.hibernate.HibernateException;
import org.hibernate.ObjectDeletedException;
@ -37,7 +37,7 @@
public class DefaultMergeEventListener extends AbstractSaveEventListener
implements MergeEventListener {
private static final Log log = LogFactory.getLog(DefaultMergeEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultMergeEventListener.class);
protected Map getMergeMap(Object anything) {
return IdentityMap.invert( (Map) anything );

6
core/src/main/java/org/hibernate/event/def/DefaultPersistEventListener.java
View File

@ -3,8 +3,8 @@
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.ObjectDeletedException;
import org.hibernate.PersistentObjectException;
@ -26,7 +26,7 @@
*/
public class DefaultPersistEventListener extends AbstractSaveEventListener implements PersistEventListener {
private static final Log log = LogFactory.getLog(DefaultPersistEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultPersistEventListener.class);
/**
* Handle the given create event.

6
core/src/main/java/org/hibernate/event/def/DefaultRefreshEventListener.java
View File

@ -4,8 +4,8 @@
import java.io.Serializable;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.PersistentObjectException;
import org.hibernate.UnresolvableObjectException;
@ -33,7 +33,7 @@
*/
public class DefaultRefreshEventListener implements RefreshEventListener {
private static final Log log = LogFactory.getLog(DefaultRefreshEventListener.class);
private static final Logger log = LoggerFactory.getLogger(DefaultRefreshEventListener.class);
public void onRefresh(RefreshEvent event) throws HibernateException {
onRefresh( event, IdentityMap.instantiate(10) );

6
core/src/main/java/org/hibernate/event/def/DefaultReplicateEventListener.java
View File

@ -19,8 +19,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Defines the default replicate event listener used by Hibernate to replicate
@ -30,7 +30,7 @@
*/
public class DefaultReplicateEventListener extends AbstractSaveEventListener implements ReplicateEventListener {
private static final Log log = LogFactory.getLog( DefaultReplicateEventListener.class );
private static final Logger log = LoggerFactory.getLogger( DefaultReplicateEventListener.class );
/**
* Handle the given replicate event.

6
core/src/main/java/org/hibernate/event/def/DefaultSaveOrUpdateEventListener.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.AssertionFailure;
import org.hibernate.EntityMode;
@ -36,7 +36,7 @@
*/
public class DefaultSaveOrUpdateEventListener extends AbstractSaveEventListener implements SaveOrUpdateEventListener {
private static final Log log = LogFactory.getLog( DefaultSaveOrUpdateEventListener.class );
private static final Logger log = LoggerFactory.getLogger( DefaultSaveOrUpdateEventListener.class );
/**
* Handle the given update event.

6
core/src/main/java/org/hibernate/event/def/EvictVisitor.java
View File

@ -1,8 +1,8 @@
//$Id: EvictVisitor.java 6929 2005-05-27 03:54:08Z oneovthafew $
package org.hibernate.event.def;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.collection.PersistentCollection;
import org.hibernate.engine.CollectionEntry;
@ -20,7 +20,7 @@
*/
public class EvictVisitor extends AbstractVisitor {
private static final Log log = LogFactory.getLog(EvictVisitor.class);
private static final Logger log = LoggerFactory.getLogger(EvictVisitor.class);
EvictVisitor(EventSource session) {
super(session);

6
core/src/main/java/org/hibernate/event/def/ReattachVisitor.java
View File

@ -3,8 +3,8 @@
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.action.CollectionRemoveAction;
import org.hibernate.event.EventSource;
@ -20,7 +20,7 @@
*/
public abstract class ReattachVisitor extends ProxyVisitor {
private static final Log log = LogFactory.getLog( ReattachVisitor.class );
private static final Logger log = LoggerFactory.getLogger( ReattachVisitor.class );
private final Serializable ownerIdentifier;
private final Object owner;

6
core/src/main/java/org/hibernate/event/def/WrapVisitor.java
View File

@ -1,8 +1,8 @@
//$Id: WrapVisitor.java 7181 2005-06-17 19:36:08Z oneovthafew $
package org.hibernate.event.def;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
import org.hibernate.collection.PersistentCollection;
@ -22,7 +22,7 @@
*/
public class WrapVisitor extends ProxyVisitor {
private static final Log log = LogFactory.getLog(WrapVisitor.class);
private static final Logger log = LoggerFactory.getLogger(WrapVisitor.class);
boolean substitute = false;

6
core/src/main/java/org/hibernate/exception/SQLExceptionConverterFactory.java
View File

@ -1,8 +1,8 @@
// $Id: SQLExceptionConverterFactory.java 4782 2004-11-21 00:11:27Z pgmjsd $
package org.hibernate.exception;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.JDBCException;
import org.hibernate.cfg.Environment;
@ -21,7 +21,7 @@
*/
public class SQLExceptionConverterFactory {
private static final Log log = LogFactory.getLog( SQLExceptionConverterFactory.class );
private static final Logger log = LoggerFactory.getLogger( SQLExceptionConverterFactory.class );
private SQLExceptionConverterFactory() {
// Private constructor - stops checkstyle from complaining.

6
core/src/main/java/org/hibernate/hql/QuerySplitter.java
View File

@ -1,8 +1,8 @@
//$Id: QuerySplitter.java 7646 2005-07-25 07:37:13Z oneovthafew $
package org.hibernate.hql;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.MappingException;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.hql.classic.ParserHelper;
@ -21,7 +21,7 @@
*/
public final class QuerySplitter {
private static final Log log = LogFactory.getLog( QuerySplitter.class );
private static final Logger log = LoggerFactory.getLogger( QuerySplitter.class );
private static final Set BEFORE_CLASS_TOKENS = new HashSet();
private static final Set NOT_AFTER_CLASS_TOKENS = new HashSet();

6
core/src/main/java/org/hibernate/hql/ast/ASTQueryTranslatorFactory.java
View File

@ -1,8 +1,8 @@
//$Id: ASTQueryTranslatorFactory.java 9162 2006-01-27 23:40:32Z steveebersole $
package org.hibernate.hql.ast;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.hql.FilterTranslator;
import org.hibernate.hql.QueryTranslator;
@ -18,7 +18,7 @@
*/
public class ASTQueryTranslatorFactory implements QueryTranslatorFactory {
private static final Log log = LogFactory.getLog( ASTQueryTranslatorFactory.class );
private static final Logger log = LoggerFactory.getLogger( ASTQueryTranslatorFactory.class );
public ASTQueryTranslatorFactory() {
log.info( "Using ASTQueryTranslatorFactory" );

10
core/src/main/java/org/hibernate/hql/ast/ErrorCounter.java
View File

@ -2,8 +2,8 @@
package org.hibernate.hql.ast;
import antlr.RecognitionException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.QueryException;
import java.util.ArrayList;
@ -14,8 +14,8 @@
* An error handler that counts parsing errors and warnings.
*/
public class ErrorCounter implements ParseErrorHandler {
private Log log = LogFactory.getLog( ErrorCounter.class );
private Log hqlLog = LogFactory.getLog( "org.hibernate.hql.PARSER" );
private Logger log = LoggerFactory.getLogger( ErrorCounter.class );
private Logger hqlLog = LoggerFactory.getLogger( "org.hibernate.hql.PARSER" );
private List errorList = new ArrayList();
private List warningList = new ArrayList();
@ -25,7 +25,7 @@ public void reportError(RecognitionException e) {
reportError( e.toString() );
recognitionExceptions.add( e );
if ( log.isDebugEnabled() ) {
log.debug( e, e );
log.debug( e.toString(), e );
}
}

6
core/src/main/java/org/hibernate/hql/ast/HqlParser.java
View File

@ -12,8 +12,8 @@
import antlr.TokenStream;
import antlr.TokenStreamException;
import antlr.collections.AST;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.hql.antlr.HqlBaseParser;
import org.hibernate.hql.antlr.HqlTokenTypes;
import org.hibernate.hql.ast.util.ASTPrinter;
@ -30,7 +30,7 @@ public final class HqlParser extends HqlBaseParser {
/**
* A logger for this class.
*/
private static final Log log = LogFactory.getLog( HqlParser.class );
private static final Logger log = LoggerFactory.getLogger( HqlParser.class );
private ParseErrorHandler parseErrorHandler;
private ASTPrinter printer = getASTPrinter();

6
core/src/main/java/org/hibernate/hql/ast/HqlSqlWalker.java
View File

@ -11,8 +11,8 @@
import java.util.Map;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.QueryException;
import org.hibernate.HibernateException;
import org.hibernate.engine.JoinSequence;
@ -88,7 +88,7 @@
* @see SqlASTFactory
*/
public class HqlSqlWalker extends HqlSqlBaseWalker implements ErrorReporter, ParameterBinder.NamedParameterSource {
private static final Log log = LogFactory.getLog( HqlSqlWalker.class );
private static final Logger log = LoggerFactory.getLogger( HqlSqlWalker.class );
private final QueryTranslatorImpl queryTranslatorImpl;
private final HqlParser hqlParser;

8
core/src/main/java/org/hibernate/hql/ast/QueryTranslatorImpl.java
View File

@ -5,8 +5,8 @@
import antlr.RecognitionException;
import antlr.TokenStreamException;
import antlr.collections.AST;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.QueryException;
@ -54,8 +54,8 @@
*/
public class QueryTranslatorImpl implements FilterTranslator {
private static final Log log = LogFactory.getLog( QueryTranslatorImpl.class );
private static final Log AST_LOG = LogFactory.getLog( "org.hibernate.hql.ast.AST" );
private static final Logger log = LoggerFactory.getLogger( QueryTranslatorImpl.class );
private static final Logger AST_LOG = LoggerFactory.getLogger( "org.hibernate.hql.ast.AST" );
private SessionFactoryImplementor factory;

6
core/src/main/java/org/hibernate/hql/ast/exec/AbstractStatementExecutor.java
View File

@ -23,7 +23,7 @@
import antlr.RecognitionException;
import antlr.collections.AST;
import org.apache.commons.logging.Log;
import org.slf4j.Logger;
/**
* Implementation of AbstractStatementExecutor.
@ -32,10 +32,10 @@
*/
public abstract class AbstractStatementExecutor implements StatementExecutor {
private final Log log;
private final Logger log;
private final HqlSqlWalker walker;
public AbstractStatementExecutor(HqlSqlWalker walker, Log log) {
public AbstractStatementExecutor(HqlSqlWalker walker, Logger log) {
this.walker = walker;
this.log = log;
}

6
core/src/main/java/org/hibernate/hql/ast/exec/BasicExecutor.java
View File

@ -18,8 +18,8 @@
import antlr.RecognitionException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Implementation of BasicExecutor.
@ -27,7 +27,7 @@
* @author Steve Ebersole
*/
public class BasicExecutor extends AbstractStatementExecutor {
private static final Log log = LogFactory.getLog( BasicExecutor.class );
private static final Logger log = LoggerFactory.getLogger( BasicExecutor.class );
private final Queryable persister;
private final String sql;

6
core/src/main/java/org/hibernate/hql/ast/exec/MultiTableDeleteExecutor.java
View File

@ -17,8 +17,8 @@
import org.hibernate.sql.Delete;
import org.hibernate.util.StringHelper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Implementation of MultiTableDeleteExecutor.
@ -26,7 +26,7 @@
* @author Steve Ebersole
*/
public class MultiTableDeleteExecutor extends AbstractStatementExecutor {
private static final Log log = LogFactory.getLog( MultiTableDeleteExecutor.class );
private static final Logger log = LoggerFactory.getLogger( MultiTableDeleteExecutor.class );
private final Queryable persister;
private final String idInsertSelect;

Some files were not shown because too many files have changed in this diff Show More