Coverage Report

Coverage Report - org.apache.ojb.odmg.locking.ReadUncommittedStrategy

Classes in this File

3.667

 package org.apache.ojb.odmg.locking;
 
 /* Copyright 2002-2005 The Apache Software Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 import org.apache.ojb.odmg.TransactionImpl;
 
 /**
  * The implementation of the Uncommited Reads Locking strategy.
  * This strategy is the loosest of them all.  It says
  * you shouldn't need to get any Read locks whatsoever,
  * but since it will probably try to get them, it will
  * always give it to them.
  *
  * Locks are obtained on modifications to the database and held until end of
  * transaction (EOT). Reading from the database does not involve any locking.
  *
  * Allows:
  * Dirty Reads
  * Non-Repeatable Reads
  * Phantom Reads
  *
  * @author Thomas Mahler & David Dixon-Peugh
  */
 public class ReadUncommittedStrategy extends AbstractLockStrategy
 {
     /**
      * acquire a read lock on Object obj for Transaction tx.
      * @param tx the transaction requesting the lock
      * @param obj the Object to be locked
      * @return true if successful, else false
      * When we read Uncommitted, we don't care about Reader locks
      */
     public boolean readLock(TransactionImpl tx, Object obj)
     {
         return true;
     }
 
     /**
      * acquire a write lock on Object obj for Transaction tx.
      * @param tx the transaction requesting the lock
      * @param obj the Object to be locked
      * @return true if successful, else false
      *
      */
     public boolean writeLock(TransactionImpl tx, Object obj)
     {
         LockEntry writer = getWriter(obj);
         if (writer == null)
         {
             if (setWriter(tx, obj))
                 return true;
             else
                 return writeLock(tx, obj);
         }
         if (writer.isOwnedBy(tx))
         {
             return true;    // If I'm the writer, then I can write.
         }
         return false;
     }
 
     /**
      * acquire a lock upgrade (from read to write) lock on Object obj for Transaction tx.
      * @param tx the transaction requesting the lock
      * @param obj the Object to be locked
      * @return true if successful, else false
      *
      */
     public boolean upgradeLock(TransactionImpl tx, Object obj)
     {
         LockEntry writer = getWriter(obj);
         if (writer == null)
         {
             if (setWriter(tx, obj))
                 return true;
             else
                 return upgradeLock(tx, obj);
         }
         if (writer.isOwnedBy(tx))
         {
             return true;    // If I already have Write, then I've upgraded.
         }
         return false;
     }
 
     /**
      * release a lock on Object obj for Transaction tx.
      * @param tx the transaction releasing the lock
      * @param obj the Object to be unlocked
      * @return true if successful, else false
      *
      */
     public boolean releaseLock(TransactionImpl tx, Object obj)
     {
         LockEntry writer = getWriter(obj);
         if (writer != null && writer.isOwnedBy(tx))
         {
             removeWriter(writer);
             return true;
         }
         // readlocks cannot (and need not) be released, thus:
         return true;
     }
 
     /**
      * checks whether the specified Object obj is read-locked by Transaction tx.
      * @param tx the transaction
      * @param obj the Object to be checked
      * @return true if lock exists, else false
      */
     public boolean checkRead(TransactionImpl tx, Object obj)
     {
         return true;
     }
 
     /**
      * checks whether the specified Object obj is write-locked by Transaction tx.
      * @param tx the transaction
      * @param obj the Object to be checked
      * @return true if lock exists, else false
      */
     public boolean checkWrite(TransactionImpl tx, Object obj)
     {
         LockEntry writer = getWriter(obj);
         return (writer != null && writer.isOwnedBy(tx));
     }
 }

1		package org.apache.ojb.odmg.locking;
2
3		/* Copyright 2002-2005 The Apache Software Foundation
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		import org.apache.ojb.odmg.TransactionImpl;
19
20		/**
21		* The implementation of the Uncommited Reads Locking strategy.
22		* This strategy is the loosest of them all. It says
23		* you shouldn't need to get any Read locks whatsoever,
24		* but since it will probably try to get them, it will
25		* always give it to them.
26		*
27		* Locks are obtained on modifications to the database and held until end of
28		* transaction (EOT). Reading from the database does not involve any locking.
29		*
30		* Allows:
31		* Dirty Reads
32		* Non-Repeatable Reads
33		* Phantom Reads
34		*
35		* @author Thomas Mahler & David Dixon-Peugh
36		*/
37		public class ReadUncommittedStrategy extends AbstractLockStrategy
38		{
39		/**
40		* acquire a read lock on Object obj for Transaction tx.
41		* @param tx the transaction requesting the lock
42		* @param obj the Object to be locked
43		* @return true if successful, else false
44		* When we read Uncommitted, we don't care about Reader locks
45		*/
46		public boolean readLock(TransactionImpl tx, Object obj)
47		{
48		return true;
49		}
50
51		/**
52		* acquire a write lock on Object obj for Transaction tx.
53		* @param tx the transaction requesting the lock
54		* @param obj the Object to be locked
55		* @return true if successful, else false
56		*
57		*/
58		public boolean writeLock(TransactionImpl tx, Object obj)
59		{
60		LockEntry writer = getWriter(obj);
61		if (writer == null)
62		{
63		if (setWriter(tx, obj))
64		return true;
65		else
66		return writeLock(tx, obj);
67		}
68		if (writer.isOwnedBy(tx))
69		{
70		return true; // If I'm the writer, then I can write.
71		}
72		return false;
73		}
74
75		/**
76		* acquire a lock upgrade (from read to write) lock on Object obj for Transaction tx.
77		* @param tx the transaction requesting the lock
78		* @param obj the Object to be locked
79		* @return true if successful, else false
80		*
81		*/
82		public boolean upgradeLock(TransactionImpl tx, Object obj)
83		{
84		LockEntry writer = getWriter(obj);
85		if (writer == null)
86		{
87		if (setWriter(tx, obj))
88		return true;
89		else
90		return upgradeLock(tx, obj);
91		}
92		if (writer.isOwnedBy(tx))
93		{
94		return true; // If I already have Write, then I've upgraded.
95		}
96		return false;
97		}
98
99		/**
100		* release a lock on Object obj for Transaction tx.
101		* @param tx the transaction releasing the lock
102		* @param obj the Object to be unlocked
103		* @return true if successful, else false
104		*
105		*/
106		public boolean releaseLock(TransactionImpl tx, Object obj)
107		{
108		LockEntry writer = getWriter(obj);
109		if (writer != null && writer.isOwnedBy(tx))
110		{
111		removeWriter(writer);
112		return true;
113		}
114		// readlocks cannot (and need not) be released, thus:
115		return true;
116		}
117
118		/**
119		* checks whether the specified Object obj is read-locked by Transaction tx.
120		* @param tx the transaction
121		* @param obj the Object to be checked
122		* @return true if lock exists, else false
123		*/
124		public boolean checkRead(TransactionImpl tx, Object obj)
125		{
126		return true;
127		}
128
129		/**
130		* checks whether the specified Object obj is write-locked by Transaction tx.
131		* @param tx the transaction
132		* @param obj the Object to be checked
133		* @return true if lock exists, else false
134		*/
135		public boolean checkWrite(TransactionImpl tx, Object obj)
136		{
137		LockEntry writer = getWriter(obj);
138		return (writer != null && writer.isOwnedBy(tx));
139		}
140		}