View as "text/plain" |
Blame |
Last modification |
View Log
| RSS feed
1
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
* indicated by the @author tags or express copyright attribution
* statements applied by the authors. All third-party contributions are
* distributed under license by Red Hat Middleware LLC.
*
* This copyrighted material is made available to anyone wishing to use, modify,
* copy, or redistribute it subject to the terms and conditions of the GNU
* Lesser General Public License, as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
* for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this distribution; if not, write to:
* Free Software Foundation, Inc.
* 51 Franklin Street, Fifth Floor
* Boston, MA 02110-1301 USA
*
*/
package org.hibernate;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
* Instances represent a lock mode for a row of a relational
* database table. It is not intended that users spend much
* time worrying about locking since Hibernate usually
* obtains exactly the right lock level automatically.
* Some "advanced" users may wish to explicitly specify lock
* levels.
*
* @see Session#lock(Object,LockMode)
* @author Gavin King
*/
public final class LockMode
implements Serializable {
private final int level
;
private final String name
;
private static final Map INSTANCES =
new HashMap();
private LockMode
(int level,
String name
) {
this.
level=level
;
this.
name=name
;
}
public String toString
() {
return name
;
}
/**
* Check if this lock mode is more restrictive than the given lock mode.
*
* @param mode LockMode to check
* @return true if this lock mode is more restrictive than given lock mode
*/
public boolean greaterThan
(LockMode mode
) {
return level
> mode.
level;
}
/**
* Check if this lock mode is less restrictive than the given lock mode.
*
* @param mode LockMode to check
* @return true if this lock mode is less restrictive than given lock mode
*/
public boolean lessThan
(LockMode mode
) {
return level
< mode.
level;
}
/**
* No lock required. If an object is requested with this lock
* mode, a <tt>READ</tt> lock will be obtained if it is
* necessary to actually read the state from the database,
* rather than pull it from a cache.<br>
* <br>
* This is the "default" lock mode.
*/
public static final LockMode NONE =
new LockMode
(0,
"NONE");
/**
* A shared lock. Objects in this lock mode were read from
* the database in the current transaction, rather than being
* pulled from a cache.
*/
public static final LockMode READ =
new LockMode
(5,
"READ");
/**
* An upgrade lock. Objects loaded in this lock mode are
* materialized using an SQL <tt>select ... for update</tt>.
*/
public static final LockMode UPGRADE =
new LockMode
(10,
"UPGRADE");
/**
* Attempt to obtain an upgrade lock, using an Oracle-style
* <tt>select for update nowait</tt>. The semantics of
* this lock mode, once obtained, are the same as
* <tt>UPGRADE</tt>.
*/
public static final LockMode UPGRADE_NOWAIT =
new LockMode
(10,
"UPGRADE_NOWAIT");
/**
* A <tt>WRITE</tt> lock is obtained when an object is updated
* or inserted. This lock mode is for internal use only and is
* not a valid mode for <tt>load()</tt> or <tt>lock()</tt> (both
* of which throw exceptions if WRITE is specified).
*/
public static final LockMode WRITE =
new LockMode
(10,
"WRITE");
/**
* Similiar to {@link #UPGRADE} except that, for versioned entities,
* it results in a forced version increment.
*/
public static final LockMode FORCE =
new LockMode
( 15,
"FORCE" );
static {
INSTANCES.
put( NONE.
name, NONE
);
INSTANCES.
put( READ.
name, READ
);
INSTANCES.
put( UPGRADE.
name, UPGRADE
);
INSTANCES.
put( UPGRADE_NOWAIT.
name, UPGRADE_NOWAIT
);
INSTANCES.
put( WRITE.
name, WRITE
);
INSTANCES.
put( FORCE.
name, FORCE
);
}
private Object readResolve
() {
return parse
( name
);
}
public static LockMode parse
(String name
) {
return ( LockMode
) INSTANCES.
get(name
);
}
}