Clover icon

Coverage Report

  1. Project Clover database Mon Nov 11 2024 15:14:12 GMT
  2. Package jalview.workers

File AlignCalcManager.java

 

Coverage histogram

../../img/srcFileCovDistChart9.png
13% of files have more coverage

Code metrics

36
114
18
1
421
321
36
0.32
6.33
18
2

Classes

Class Line # Actions
AlignCalcManager 36 114 36
0.821428682.1%
 

Contributing tests

This file is covered by 249 tests. .

Source view

1    /*
2    * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3    * Copyright (C) $$Year-Rel$$ The Jalview Authors
4    *
5    * This file is part of Jalview.
6    *
7    * Jalview is free software: you can redistribute it and/or
8    * modify it under the terms of the GNU General Public License
9    * as published by the Free Software Foundation, either version 3
10    * of the License, or (at your option) any later version.
11    *
12    * Jalview is distributed in the hope that it will be useful, but
13    * WITHOUT ANY WARRANTY; without even the implied warranty
14    * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15    * PURPOSE. See the GNU General Public License for more details.
16    *
17    * You should have received a copy of the GNU General Public License
18    * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19    * The Jalview Authors are detailed in the 'AUTHORS' file.
20    */
21    package jalview.workers;
22   
23    import java.util.ArrayList;
24    import java.util.Collection;
25    import java.util.Collections;
26    import java.util.HashSet;
27    import java.util.Hashtable;
28    import java.util.List;
29    import java.util.Map;
30    import java.util.Set;
31   
32    import jalview.api.AlignCalcManagerI;
33    import jalview.api.AlignCalcWorkerI;
34    import jalview.datamodel.AlignmentAnnotation;
35   
 
36    public class AlignCalcManager implements AlignCalcManagerI
37    {
38    /*
39    * list of registered workers
40    */
41    private volatile List<AlignCalcWorkerI> restartable;
42   
43    /*
44    * types of worker _not_ to run (for example, because they have
45    * previously thrown errors)
46    */
47    private volatile List<Class<? extends AlignCalcWorkerI>> blackList;
48   
49    /*
50    * global record of calculations in progress
51    */
52    private volatile List<AlignCalcWorkerI> inProgress;
53   
54    /*
55    * record of calculations pending or in progress in the current context
56    */
57    private volatile Map<Class<? extends AlignCalcWorkerI>, List<AlignCalcWorkerI>> updating;
58   
59    /*
60    * workers that have run to completion so are candidates for visual-only
61    * update of their results
62    */
63    private HashSet<AlignCalcWorkerI> canUpdate;
64   
65    /**
66    * Constructor
67    */
 
68  508 toggle public AlignCalcManager()
69    {
70  508 restartable = Collections
71    .synchronizedList(new ArrayList<AlignCalcWorkerI>());
72  508 blackList = Collections.synchronizedList(
73    new ArrayList<Class<? extends AlignCalcWorkerI>>());
74  508 inProgress = Collections
75    .synchronizedList(new ArrayList<AlignCalcWorkerI>());
76  508 updating = Collections.synchronizedMap(
77    new Hashtable<Class<? extends AlignCalcWorkerI>, List<AlignCalcWorkerI>>());
78  508 canUpdate = new HashSet<AlignCalcWorkerI>();
79    }
80   
 
81  2060 toggle @Override
82    public void notifyStart(AlignCalcWorkerI worker)
83    {
84  2060 synchronized (updating)
85    {
86  2060 List<AlignCalcWorkerI> upd = updating.get(worker.getClass());
87  2060 if (upd == null)
88    {
89  820 updating.put(worker.getClass(), upd = Collections
90    .synchronizedList(new ArrayList<AlignCalcWorkerI>()));
91    }
92  2060 synchronized (upd)
93    {
94  2060 upd.add(worker);
95    }
96    }
97    }
98   
99    /*
100    * (non-Javadoc)
101    *
102    * @see jalview.api.AlignCalcManagerI#isPending(jalview.api.AlignCalcWorkerI)
103    */
 
104  2088 toggle @Override
105    public boolean isPending(AlignCalcWorkerI workingClass)
106    {
107  2088 List<AlignCalcWorkerI> upd;
108  2088 synchronized (updating)
109    {
110  2088 upd = updating.get(workingClass.getClass());
111  2088 if (upd == null)
112    {
113  453 return false;
114    }
115  1635 synchronized (upd)
116    {
117  1635 if (upd.size() > 1)
118    {
119  59 return true;
120    }
121    }
122  1576 return false;
123    }
124    }
125   
 
126  2218 toggle @Override
127    public boolean notifyWorking(AlignCalcWorkerI worker)
128    {
129  2218 synchronized (inProgress)
130    {
131  2218 if (inProgress.contains(worker))
132    {
133  225 return false; // worker is already working, so ask caller to wait around
134    }
135    else
136    {
137  1993 inProgress.add(worker);
138    }
139    }
140  1993 return true;
141    }
142   
 
143  2127 toggle @Override
144    public void workerComplete(AlignCalcWorkerI worker)
145    {
146  2127 synchronized (inProgress)
147    {
148    // jalview.bin.Console.errPrintln("Worker " + worker + " marked as
149    // complete.");
150  2127 inProgress.remove(worker);
151  2127 List<AlignCalcWorkerI> upd = updating.get(worker.getClass());
152  2127 if (upd != null)
153    {
154  2127 synchronized (upd)
155    {
156  2127 upd.remove(worker);
157    }
158  2127 canUpdate.add(worker);
159    }
160    }
161    }
162   
 
163  0 toggle @Override
164    public void disableWorker(AlignCalcWorkerI worker)
165    {
166  0 synchronized (blackList)
167    {
168  0 blackList.add(worker.getClass());
169    }
170    }
171   
 
172  2069 toggle @Override
173    public boolean isDisabled(AlignCalcWorkerI worker)
174    {
175  2069 synchronized (blackList)
176    {
177  2069 return blackList.contains(worker.getClass());
178    }
179    }
180   
 
181  2063 toggle @Override
182    public void startWorker(AlignCalcWorkerI worker)
183    {
184  2063 if (!isDisabled(worker))
185    {
186  2063 Thread tw = new Thread(worker);
187  2063 tw.setName(worker.getClass().toString());
188  2063 tw.start();
189    }
190    }
191   
 
192  18 toggle @Override
193    public boolean isWorking(AlignCalcWorkerI worker)
194    {
195  18 synchronized (inProgress)
196    {// jalview.bin.Console.errPrintln("isWorking : worker "+(worker!=null ?
197    // worker.getClass():"null")+ " "+hashCode());
198  18 return worker != null && inProgress.contains(worker);
199    }
200    }
201   
 
202  3208 toggle @Override
203    public boolean isWorking()
204    {
205  3208 boolean working = false;
206  3208 synchronized (inProgress)
207    {
208    // jalview.bin.Console.errPrintln("isWorking "+hashCode());
209  3208 working |= inProgress.size() > 0;
210    }
211  3208 synchronized (updating)
212    {
213  3208 Collection<List<AlignCalcWorkerI>> workersLists = updating.values();
214  3208 synchronized (workersLists)
215    {
216  3208 for (List<AlignCalcWorkerI> workers : workersLists)
217    {
218  6029 if (workers != null)
219    {
220  6029 synchronized (workers)
221    {
222  6029 working |= workers.size() > 0;
223    }
224    }
225    }
226    }
227    }
228  3208 return working;
229    }
230   
 
231  908 toggle @Override
232    public void registerWorker(AlignCalcWorkerI worker)
233    {
234  908 synchronized (restartable)
235    {
236  908 if (!restartable.contains(worker))
237    {
238  908 restartable.add(worker);
239    }
240  908 startWorker(worker);
241    }
242    }
243   
 
244  549 toggle @Override
245    public void restartWorkers()
246    {
247  549 synchronized (restartable)
248    {
249  549 for (AlignCalcWorkerI worker : restartable)
250    {
251  1155 startWorker(worker);
252    }
253    }
254    }
255   
 
256  10444 toggle @Override
257    public boolean workingInvolvedWith(
258    AlignmentAnnotation alignmentAnnotation)
259    {
260  10444 synchronized (inProgress)
261    {
262  10444 for (AlignCalcWorkerI worker : inProgress)
263    {
264  698 if (worker.involves(alignmentAnnotation))
265    {
266  242 return true;
267    }
268    }
269    }
270  10202 synchronized (updating)
271    {
272  10202 for (List<AlignCalcWorkerI> workers : updating.values())
273    {
274  19736 for (AlignCalcWorkerI worker : workers)
275    {
276  696 if (worker.involves(alignmentAnnotation))
277    {
278  74 return true;
279    }
280    }
281    }
282    }
283  10128 return false;
284    }
285   
 
286  48 toggle @Override
287    public void updateAnnotationFor(
288    Class<? extends AlignCalcWorkerI> workerClass)
289    {
290   
291  48 AlignCalcWorkerI[] workers;
292  48 synchronized (canUpdate)
293    {
294  48 workers = canUpdate.toArray(new AlignCalcWorkerI[0]);
295    }
296  48 for (AlignCalcWorkerI worker : workers)
297    {
298  95 if (workerClass.equals(worker.getClass()))
299    {
300  18 worker.updateAnnotation();
301    }
302    }
303    }
304   
 
305  3652 toggle @Override
306    public List<AlignCalcWorkerI> getRegisteredWorkersOfClass(
307    Class<? extends AlignCalcWorkerI> workerClass)
308    {
309  3652 List<AlignCalcWorkerI> workingClass = new ArrayList<AlignCalcWorkerI>();
310  3652 AlignCalcWorkerI[] workers;
311  3652 synchronized (canUpdate)
312    {
313  3652 workers = canUpdate.toArray(new AlignCalcWorkerI[0]);
314    }
315  3652 for (AlignCalcWorkerI worker : workers)
316    {
317  5368 if (workerClass.equals(worker.getClass()))
318    {
319  976 workingClass.add(worker);
320    }
321    }
322  3652 return (workingClass.size() == 0) ? null : workingClass;
323    }
324   
 
325  0 toggle @Override
326    public void enableWorker(AlignCalcWorkerI worker)
327    {
328  0 synchronized (blackList)
329    {
330  0 blackList.remove(worker.getClass());
331    }
332    }
333   
 
334  0 toggle @Override
335    public void removeRegisteredWorkersOfClass(
336    Class<? extends AlignCalcWorkerI> typeToRemove)
337    {
338  0 List<AlignCalcWorkerI> removable = new ArrayList<AlignCalcWorkerI>();
339  0 Set<AlignCalcWorkerI> toremovannot = new HashSet<AlignCalcWorkerI>();
340  0 synchronized (restartable)
341    {
342  0 for (AlignCalcWorkerI worker : restartable)
343    {
344  0 if (typeToRemove.equals(worker.getClass()))
345    {
346  0 removable.add(worker);
347  0 toremovannot.add(worker);
348    }
349    }
350  0 restartable.removeAll(removable);
351    }
352  0 synchronized (canUpdate)
353    {
354  0 for (AlignCalcWorkerI worker : canUpdate)
355    {
356  0 if (typeToRemove.equals(worker.getClass()))
357    {
358  0 removable.add(worker);
359  0 toremovannot.add(worker);
360    }
361    }
362  0 canUpdate.removeAll(removable);
363    }
364    // TODO: finish testing this extension
365   
366    /*
367    * synchronized (inProgress) { // need to kill or mark as dead any running
368    * threads... (inProgress.get(typeToRemove)); }
369    *
370    * if (workers == null) { return; } for (AlignCalcWorkerI worker : workers)
371    * {
372    *
373    * if (isPending(worker)) { worker.abortAndDestroy(); startWorker(worker); }
374    * else { jalview.bin.Console.errPrintln("Pending exists for " + workerClass); } }
375    */
376    }
377   
378    /**
379    * Deletes the worker that update the given annotation, provided it is marked
380    * as deletable.
381    */
 
382  2 toggle @Override
383    public void removeWorkerForAnnotation(AlignmentAnnotation ann)
384    {
385    /*
386    * first just find those to remove (to avoid
387    * ConcurrentModificationException)
388    */
389  2 List<AlignCalcWorkerI> toRemove = new ArrayList<AlignCalcWorkerI>();
390  2 for (AlignCalcWorkerI worker : restartable)
391    {
392  8 if (worker.involves(ann))
393    {
394  2 if (worker.isDeletable())
395    {
396  1 toRemove.add(worker);
397    }
398    }
399    }
400   
401    /*
402    * remove all references to deleted workers so any references
403    * they hold to annotation data can be garbage collected
404    */
405  2 for (AlignCalcWorkerI worker : toRemove)
406    {
407  1 restartable.remove(worker);
408  1 blackList.remove(worker.getClass());
409  1 inProgress.remove(worker);
410  1 canUpdate.remove(worker);
411  1 synchronized (updating)
412    {
413  1 List<AlignCalcWorkerI> upd = updating.get(worker.getClass());
414  1 if (upd != null)
415    {
416  1 upd.remove(worker);
417    }
418    }
419    }
420    }
421    }
  • Report generated by OpenClover v 4.4.1 on Mon Nov 11 2024 15:21:34 GMT using coverage data from Mon Nov 11 2024 15:21:19 GMT.
  • OpenClover is free and open-source software.