Coverage Report - com.liquidatom.derbyscore.domain.Team
 
Classes in this File Line Coverage Branch Coverage Complexity
Team
0%
0/117
0%
0/36
2.45
 
 1  
 package com.liquidatom.derbyscore.domain;
 2  
 
 3  
 import java.awt.image.BufferedImage;
 4  
 import java.util.LinkedHashSet;
 5  
 import java.util.Set;
 6  
 import java.util.concurrent.locks.Lock;
 7  
 import java.util.concurrent.locks.ReadWriteLock;
 8  
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 9  
 import javax.annotation.concurrent.GuardedBy;
 10  
 import javax.annotation.concurrent.ThreadSafe;
 11  
 
 12  
 /**
 13  
  * Domain object which represents a team.
 14  
  *
 15  
  * @author Russell Francis (russ@metro-six.com)
 16  
  */
 17  
 @ThreadSafe
 18  0
 public class Team implements ReadWriteLock {
 19  
 
 20  0
     private final ReadWriteLock lock = new ReentrantReadWriteLock();
 21  
 
 22  
     @GuardedBy("lock")
 23  
     private String name;
 24  
 
 25  
     @GuardedBy("lock")
 26  
     private BufferedImage image;
 27  
 
 28  0
     @GuardedBy("lock")
 29  
     private int score = 0;
 30  
 
 31  0
     @GuardedBy("lock")
 32  
     private int jamPoints = 0;
 33  
 
 34  0
     @GuardedBy("lock")
 35  
     private int timeouts = 3;
 36  
 
 37  
     @GuardedBy("lock")
 38  
     private Bout bout;
 39  
 
 40  0
     @GuardedBy("itself")
 41  
     private final Set<TeamListener> teamListeners = new LinkedHashSet<TeamListener>();
 42  
 
 43  
     public boolean addListener(TeamListener listener) {
 44  0
         synchronized (teamListeners) {
 45  0
             return teamListeners.add(listener);
 46  0
         }
 47  
     }
 48  
 
 49  
     public boolean removeListener(TeamListener listener) {
 50  0
         synchronized (teamListeners) {
 51  0
             return teamListeners.remove(listener);
 52  0
         }
 53  
     }
 54  
 
 55  
     protected void fireOnChanged() {
 56  0
         synchronized (teamListeners) {
 57  0
             for (TeamListener listener : teamListeners) {
 58  0
                 listener.onChanged(this);
 59  
             }
 60  0
         }
 61  0
     }
 62  
 
 63  
     public Bout getBout() {
 64  0
         readLock().lock();
 65  
         try {
 66  0
             return bout;
 67  
         }
 68  
         finally {
 69  0
             readLock().unlock();
 70  
         }
 71  
     }
 72  
 
 73  
     public void setBout(final Bout bout) {
 74  0
         writeLock().lock();
 75  
         try {
 76  0
             this.bout = bout;
 77  
         }
 78  
         finally {
 79  0
             writeLock().unlock();
 80  0
         }
 81  0
     }
 82  
     
 83  
     public String getName() {
 84  0
         readLock().lock();
 85  
         try {
 86  0
             return name;
 87  
         }
 88  
         finally {
 89  0
             readLock().unlock();
 90  
         }
 91  
     }
 92  
 
 93  
     public void setName(final String name) {
 94  0
         if (name == null) {
 95  0
             throw new IllegalArgumentException("The parameter name must be non-null.");
 96  
         }
 97  
 
 98  0
         boolean fireOnChange = false;
 99  0
         writeLock().lock();
 100  
         try {
 101  0
             if (!name.equals(this.name)) {
 102  0
                 fireOnChange = true;
 103  0
                 this.name = name;
 104  
             }
 105  
         }
 106  
         finally {
 107  0
             writeLock().unlock();
 108  0
         }
 109  
 
 110  0
         if (fireOnChange) {
 111  0
             fireOnChanged();
 112  
         }
 113  0
     }
 114  
 
 115  
     public BufferedImage getImage() {
 116  0
         readLock().lock();
 117  
         try {
 118  0
             return image;
 119  
         }
 120  
         finally {
 121  0
             readLock().unlock();
 122  
         }
 123  
     }
 124  
 
 125  
     public void setImage(final BufferedImage image) {
 126  0
         writeLock().lock();
 127  
         try {
 128  0
             this.image = image;
 129  
         }
 130  
         finally {
 131  0
             writeLock().unlock();
 132  0
         }
 133  0
         fireOnChanged();
 134  0
     }
 135  
 
 136  
     public int getTimeouts() {
 137  0
         readLock().lock();
 138  
         try {
 139  0
             return timeouts;
 140  
         }
 141  
         finally {
 142  0
             readLock().unlock();
 143  
         }
 144  
     }
 145  
 
 146  
     public void setTimeouts(final int timeouts) {
 147  0
         if (timeouts < 0) {
 148  0
             throw new IllegalArgumentException("The parameter timeouts must be >= 0.");
 149  
         }
 150  0
         if (timeouts > 3) {
 151  0
             throw new IllegalArgumentException("The parameter timeouts must be <= 3.");
 152  
         }
 153  
 
 154  0
         boolean fireOnChange = false;
 155  0
         writeLock().lock();
 156  
         try {
 157  0
             if (timeouts != this.timeouts) {
 158  0
                 fireOnChange = true;
 159  0
                 this.timeouts = timeouts;
 160  
             }
 161  
         }
 162  
         finally {
 163  0
             writeLock().unlock();
 164  0
         }
 165  
 
 166  0
         if (fireOnChange) {
 167  0
             fireOnChanged();
 168  
         }
 169  0
     }
 170  
 
 171  
     public int getJamPoints() {
 172  0
         readLock().lock();
 173  
         try {
 174  0
             return jamPoints;
 175  
         }
 176  
         finally {
 177  0
             readLock().unlock();
 178  
         }
 179  
     }
 180  
 
 181  
     public void setJamPoints(final int jamPoints) {
 182  0
         if (jamPoints < 0) {
 183  0
             throw new IllegalArgumentException("The parameter jamPoints must be greater than or equal to zero.");
 184  
         }
 185  
 
 186  0
         boolean fireOnChange = false;
 187  0
         writeLock().lock();
 188  
         try {
 189  0
             if (jamPoints != this.jamPoints) {
 190  0
                 fireOnChange = true;
 191  0
                 this.jamPoints = jamPoints;
 192  
             }
 193  
         }
 194  
         finally {
 195  0
             writeLock().unlock();
 196  0
         }
 197  
 
 198  0
         if (fireOnChange) {
 199  0
             fireOnChanged();
 200  
         }
 201  0
     }
 202  
 
 203  
     public String getJamPointsString() {
 204  0
         String value = Integer.valueOf(getJamPoints()).toString();
 205  0
         while (value.length() < 2) {
 206  0
             value = "0" + value;
 207  
         }
 208  0
         return value;
 209  
     }
 210  
 
 211  
     public void applyJamPoints() {
 212  0
         boolean fireOnChanged = false;
 213  0
         writeLock().lock();
 214  
         try {
 215  0
             if (jamPoints != 0) {
 216  0
                 fireOnChanged = true;
 217  0
                 score += jamPoints;
 218  0
                 jamPoints = 0;
 219  
             }
 220  
         }
 221  
         finally {
 222  0
             writeLock().unlock();
 223  0
         }
 224  
 
 225  0
         if (fireOnChanged) {
 226  0
             fireOnChanged();
 227  
         }
 228  0
     }
 229  
 
 230  
     public int getScore() {
 231  0
         readLock().lock();
 232  
         try {
 233  0
             return score;
 234  
         }
 235  
         finally {
 236  0
             readLock().unlock();
 237  
         }
 238  
     }
 239  
 
 240  
     public void setScore(final int score) {
 241  0
         if (score < 0) {
 242  0
             throw new IllegalArgumentException("The parameter score must be >= 0");
 243  
         }
 244  
 
 245  0
         boolean fireOnChanged = false;
 246  
 
 247  0
         writeLock().lock();
 248  
         try {
 249  0
             if (score != this.score) {
 250  0
                 fireOnChanged = true;
 251  0
                 this.score = score;
 252  
             }
 253  
         }
 254  
         finally {
 255  0
             writeLock().unlock();
 256  0
         }
 257  
 
 258  0
         if (fireOnChanged) {
 259  0
             fireOnChanged();
 260  
         }
 261  0
     }
 262  
 
 263  
     public String getScoreString() {
 264  0
         String value = Integer.valueOf(getScore()).toString();
 265  0
         while (value.length() < 3) {
 266  0
             value = "0" + value;
 267  
         }
 268  0
         return value;
 269  
     }
 270  
 
 271  
     public Lock readLock() {
 272  0
         return lock.readLock();
 273  
     }
 274  
 
 275  
     public Lock writeLock() {
 276  0
         return lock.writeLock();
 277  
     }
 278  
 }