Clover coverage report -
Coverage timestamp: Thu Jul 5 2007 20:02:32 EDT
file stats: LOC: 184   Methods: 14
NCLOC: 101   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
LockMap.java 66.7% 89.7% 100% 89.8%
coverage coverage
 1    /*
 2    * JBoss, the OpenSource J2EE webOS
 3    *
 4    * Distributable under LGPL license.
 5    * See terms of license at gnu.org.
 6    */
 7    package org.jboss.cache.lock;
 8   
 9    import java.util.Collections;
 10    import java.util.Set;
 11    import java.util.concurrent.CopyOnWriteArraySet;
 12   
 13    /**
 14    * Provide lock ownership mapping.
 15    *
 16    * @author Ben Wang
 17    * @version $Id: LockMap.java,v 1.13 2007/05/23 15:22:04 msurtani Exp $
 18    */
 19    public class LockMap
 20    {
 21    public static final int OWNER_ANY = 0;
 22    public static final int OWNER_READ = 1;
 23    public static final int OWNER_WRITE = 2;
 24   
 25    private Object writeOwner_ = null;
 26   
 27    // a CopyOnWriteArraySet is HUGELY inefficient since MANY LockMaps are created and are frequently read from. Until we have a better impl ...
 28    private final Set readOwnerList_ = new CopyOnWriteArraySet();
 29   
 30  180145 public LockMap()
 31    {
 32    }
 33   
 34   
 35    /**
 36    * Check whether this owner has reader or writer ownership.
 37    *
 38    * @param caller the potential owner. Cannot be <code>null</code>.
 39    * @param ownership Either <code>OWNER_ANY</code>, <code>OWNER_READ</code>,
 40    * or <code>OWNER_WRITE</code>.
 41    * @return
 42    * @throws NullPointerException if <code>caller</code> is <code>null</code>.
 43    */
 44  16336973 public boolean isOwner(Object caller, int ownership)
 45    {
 46    /* This method doesn't need to be synchronized; the thread is doing a simple read access (writer, readers)
 47    and only the current thread can *change* the writer or readers, so this cannot happen while we read.
 48    */
 49   
 50  16336973 switch (ownership)
 51    {
 52  7971429 case OWNER_ANY:
 53  7971429 return (writeOwner_ != null && caller.equals(writeOwner_) || readOwnerList_.contains(caller));
 54  7350920 case OWNER_READ:
 55  7350970 return (readOwnerList_.contains(caller));
 56  1014574 case OWNER_WRITE:
 57  1014574 return (writeOwner_ != null && caller.equals(writeOwner_));
 58  0 default:
 59  0 return false;
 60    }
 61    }
 62   
 63   
 64    /**
 65    * Adding a reader owner.
 66    *
 67    * @param owner
 68    */
 69  6436240 public void addReader(Object owner)
 70    {
 71  6436234 readOwnerList_.add(owner);
 72    }
 73   
 74    /**
 75    * Adding a writer owner.
 76    *
 77    * @param owner
 78    */
 79  442250 public void setWriterIfNotNull(Object owner)
 80    {
 81  442250 synchronized (this)
 82    {
 83  442250 if (writeOwner_ != null)
 84  0 throw new IllegalStateException("there is already a writer holding the lock: " + writeOwner_);
 85  442250 writeOwner_ = owner;
 86    }
 87    }
 88   
 89  14006 private Object setWriter(Object owner)
 90    {
 91  14006 Object old;
 92  14006 synchronized (this)
 93    {
 94  14006 old = writeOwner_;
 95  14006 writeOwner_ = owner;
 96    }
 97  14006 return old;
 98    }
 99   
 100   
 101    /**
 102    * Upgrading current reader ownership to writer one.
 103    *
 104    * @param owner
 105    * @return True if successful.
 106    */
 107  14006 public boolean upgrade(Object owner) throws OwnerNotExistedException
 108    {
 109  14006 boolean old_value = readOwnerList_.remove(owner);
 110  14006 if (!old_value) // didn't exist in the list
 111  0 throw new OwnerNotExistedException("Can't upgrade lock. Read lock owner did not exist");
 112  14006 setWriter(owner);
 113  14006 return true;
 114    }
 115   
 116    /**
 117    * Returns an unmodifiable set of reader owner objects.
 118    */
 119  26278 public Set readerOwners()
 120    {
 121  26278 return Collections.unmodifiableSet(readOwnerList_);
 122    }
 123   
 124  291 public void releaseReaderOwners(LockStrategy lock)
 125    {
 126  291 int size = readOwnerList_.size();
 127  291 for (int i = 0; i < size; i++)
 128  5 lock.readLock().unlock();
 129    }
 130   
 131    /**
 132    * @return Writer owner object. Null if none.
 133    */
 134  251794 public Object writerOwner()
 135    {
 136  251794 return writeOwner_;
 137    }
 138   
 139    /**
 140    * Remove reader ownership.
 141    */
 142  6422113 public void removeReader(Object owner)
 143    {
 144  6422113 readOwnerList_.remove(owner);
 145    }
 146   
 147    /**
 148    * Remove writer ownership.
 149    */
 150  456110 public void removeWriter()
 151    {
 152  456110 synchronized (this)
 153    {
 154  456110 writeOwner_ = null;
 155    }
 156    }
 157   
 158    /**
 159    * Remove all ownership.
 160    */
 161  295 public void removeAll()
 162    {
 163  295 removeWriter();
 164  295 readOwnerList_.clear();
 165    }
 166   
 167    /**
 168    * Debugging information.
 169    *
 170    * @return
 171    */
 172  78 public String printInfo()
 173    {
 174  78 StringBuffer buf = new StringBuffer(64);
 175  78 buf.append("Read lock owners: ").append(readOwnerList_).append('\n');
 176  78 buf.append("Write lock owner: ").append(writeOwner_).append('\n');
 177  78 return buf.toString();
 178    }
 179   
 180  225564 public boolean isReadLocked()
 181    {
 182  225564 return !readOwnerList_.isEmpty();
 183    }
 184    }