Coverage Report

Coverage Report - com.liquidatom.derbyscore.domain.Team

Classes in this File

Line Coverage

Branch Coverage

Complexity

Team

0/117

0/36

2.45

 package com.liquidatom.derbyscore.domain;
 
 import java.awt.image.BufferedImage;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import javax.annotation.concurrent.GuardedBy;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
  * Domain object which represents a team.
  *
  * @author Russell Francis (russ@metro-six.com)
  */
 @ThreadSafe
 public class Team implements ReadWriteLock {
 
     private final ReadWriteLock lock = new ReentrantReadWriteLock();
 
     @GuardedBy("lock")
     private String name;
 
     @GuardedBy("lock")
     private BufferedImage image;
 
     @GuardedBy("lock")
     private int score = 0;
 
     @GuardedBy("lock")
     private int jamPoints = 0;
 
     @GuardedBy("lock")
     private int timeouts = 3;
 
     @GuardedBy("lock")
     private Bout bout;
 
     @GuardedBy("itself")
     private final Set<TeamListener> teamListeners = new LinkedHashSet<TeamListener>();
 
     public boolean addListener(TeamListener listener) {
         synchronized (teamListeners) {
             return teamListeners.add(listener);
         }
     }
 
     public boolean removeListener(TeamListener listener) {
         synchronized (teamListeners) {
             return teamListeners.remove(listener);
         }
     }
 
     protected void fireOnChanged() {
         synchronized (teamListeners) {
             for (TeamListener listener : teamListeners) {
                 listener.onChanged(this);
             }
         }
     }
 
     public Bout getBout() {
         readLock().lock();
         try {
             return bout;
         }
         finally {
             readLock().unlock();
         }
     }
 
     public void setBout(final Bout bout) {
         writeLock().lock();
         try {
             this.bout = bout;
         }
         finally {
             writeLock().unlock();
         }
     }
     
     public String getName() {
         readLock().lock();
         try {
             return name;
         }
         finally {
             readLock().unlock();
         }
     }
 
     public void setName(final String name) {
         if (name == null) {
             throw new IllegalArgumentException("The parameter name must be non-null.");
         }
 
         boolean fireOnChange = false;
         writeLock().lock();
         try {
             if (!name.equals(this.name)) {
                 fireOnChange = true;
                 this.name = name;
             }
         }
         finally {
             writeLock().unlock();
         }
 
         if (fireOnChange) {
             fireOnChanged();
         }
     }
 
     public BufferedImage getImage() {
         readLock().lock();
         try {
             return image;
         }
         finally {
             readLock().unlock();
         }
     }
 
     public void setImage(final BufferedImage image) {
         writeLock().lock();
         try {
             this.image = image;
         }
         finally {
             writeLock().unlock();
         }
         fireOnChanged();
     }
 
     public int getTimeouts() {
         readLock().lock();
         try {
             return timeouts;
         }
         finally {
             readLock().unlock();
         }
     }
 
     public void setTimeouts(final int timeouts) {
         if (timeouts < 0) {
             throw new IllegalArgumentException("The parameter timeouts must be >= 0.");
         }
         if (timeouts > 3) {
             throw new IllegalArgumentException("The parameter timeouts must be <= 3.");
         }
 
         boolean fireOnChange = false;
         writeLock().lock();
         try {
             if (timeouts != this.timeouts) {
                 fireOnChange = true;
                 this.timeouts = timeouts;
             }
         }
         finally {
             writeLock().unlock();
         }
 
         if (fireOnChange) {
             fireOnChanged();
         }
     }
 
     public int getJamPoints() {
         readLock().lock();
         try {
             return jamPoints;
         }
         finally {
             readLock().unlock();
         }
     }
 
     public void setJamPoints(final int jamPoints) {
         if (jamPoints < 0) {
             throw new IllegalArgumentException("The parameter jamPoints must be greater than or equal to zero.");
         }
 
         boolean fireOnChange = false;
         writeLock().lock();
         try {
             if (jamPoints != this.jamPoints) {
                 fireOnChange = true;
                 this.jamPoints = jamPoints;
             }
         }
         finally {
             writeLock().unlock();
         }
 
         if (fireOnChange) {
             fireOnChanged();
         }
     }
 
     public String getJamPointsString() {
         String value = Integer.valueOf(getJamPoints()).toString();
         while (value.length() < 2) {
             value = "0" + value;
         }
         return value;
     }
 
     public void applyJamPoints() {
         boolean fireOnChanged = false;
         writeLock().lock();
         try {
             if (jamPoints != 0) {
                 fireOnChanged = true;
                 score += jamPoints;
                 jamPoints = 0;
             }
         }
         finally {
             writeLock().unlock();
         }
 
         if (fireOnChanged) {
             fireOnChanged();
         }
     }
 
     public int getScore() {
         readLock().lock();
         try {
             return score;
         }
         finally {
             readLock().unlock();
         }
     }
 
     public void setScore(final int score) {
         if (score < 0) {
             throw new IllegalArgumentException("The parameter score must be >= 0");
         }
 
         boolean fireOnChanged = false;
 
         writeLock().lock();
         try {
             if (score != this.score) {
                 fireOnChanged = true;
                 this.score = score;
             }
         }
         finally {
             writeLock().unlock();
         }
 
         if (fireOnChanged) {
             fireOnChanged();
         }
     }
 
     public String getScoreString() {
         String value = Integer.valueOf(getScore()).toString();
         while (value.length() < 3) {
             value = "0" + value;
         }
         return value;
     }
 
     public Lock readLock() {
         return lock.readLock();
     }
 
     public Lock writeLock() {
         return lock.writeLock();
     }
 }

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		}