Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
AnnotationSorter	41	107	69	0.00%	Show methods
AnnotationSorter.SequenceAnnotationOrder	52	6	4	0.00%	Show methods

Class AnnotationSorter

Class AnnotationSorter	Line # 41	Total Statements 107	Complexity 69	TOTAL Coverage 0.00%
AnnotationSorter(AlignmentI,boolean)   AnnotationSorter(AlignmentI,boolean)	100100	2.02	1.01	0.0 0.00%
compare(AlignmentAnnotation,AlignmentAnnotation) : int   compare(AlignmentAnnotation,AlignmentAnnotation) : int	120120	20.020	13.013	0.0 0.00%
toString() : String   toString() : String	171171	1.01	1.01	0.0 0.00%
compare(AlignmentAnnotation,AlignmentAnnotation) : int   compare(AlignmentAnnotation,AlignmentAnnotation) : int	190190	16.016	12.012	0.0 0.00%
toString() : String   toString() : String	233233	1.01	1.01	0.0 0.00%
compare(AlignmentAnnotation,AlignmentAnnotation) : int   compare(AlignmentAnnotation,AlignmentAnnotation) : int	248248	8.08	9.09	0.0 0.00%
toString() : String   toString() : String	270270	1.01	1.01	0.0 0.00%
sort(AlignmentAnnotation[],SequenceAnnotationOrder) : void   sort(AlignmentAnnotation[],SequenceAnnotationOrder) : void	283283	7.07	3.03	0.0 0.00%
saveSequenceIndices(AlignmentAnnotation[]) : void   saveSequenceIndices(AlignmentAnnotation[]) : void	312312	6.06	2.02	0.0 0.00%
getComparator(SequenceAnnotationOrder) : Comparator<? super AlignmentAnnotation>   getComparator(SequenceAnnotationOrder) : Comparator<? super AlignmentAnnotation>	333333	11.011	5.05	0.0 0.00%
compareLabels(AlignmentAnnotation,AlignmentAnnotation) : int   compareLabels(AlignmentAnnotation,AlignmentAnnotation) : int	361361	5.05	3.03	0.0 0.00%
compareDescriptions(AlignmentAnnotation,AlignmentAnnotation) : int   compareDescriptions(AlignmentAnnotation,AlignmentAnnotation) : int	380380	5.05	3.03	0.0 0.00%
compareString(String,String) : int   compareString(String,String) : int	392392	7.07	5.05	0.0 0.00%
compareSequences(AlignmentAnnotation,AlignmentAnnotation) : int   compareSequences(AlignmentAnnotation,AlignmentAnnotation) : int	418418	17.017	10.010	0.0 0.00%

 

Class AnnotationSorter.SequenceAnnotationOrder

Class AnnotationSorter.SequenceAnnotationOrder	Line # 52	Total Statements 6	Complexity 4	TOTAL Coverage 0.00%
SequenceAnnotationOrder(String)   SequenceAnnotationOrder(String)	6060	1.01	1.01	0.0 0.00%
toString() : String   toString() : String	6565	1.01	1.01	0.0 0.00%
forDescription(String) : SequenceAnnotationOrder   forDescription(String) : SequenceAnnotationOrder	7171	4.04	2.02	0.0 0.00%

 

Contributing 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.analysis;
22
23		import java.util.Locale;
24
25		import jalview.datamodel.AlignmentAnnotation;
26		import jalview.datamodel.AlignmentI;
27		import jalview.datamodel.SequenceI;
28
29		import java.util.Arrays;
30		import java.util.Comparator;
31		import java.util.HashMap;
32		import java.util.Map;
33
34		/**
35		* A helper class to sort all annotations associated with an alignment in
36		* various ways.
37		*
38		* @author gmcarstairs
39		*
40		*/
		0% Uncovered Elements: 203 (203) Complexity: 69 Complexity Density: 0.64
41		public class AnnotationSorter
42		{
43
44		/**
45		* enum for annotation sort options. The text description is used in the
46		* Preferences drop-down options. The enum name is saved in the preferences
47		* file.
48		*
49		* @author gmcarstairs
50		*
51		*/
		0% Uncovered Elements: 11 (11) Complexity: 4 Complexity Density: 0.67
52		public enum SequenceAnnotationOrder
53		{
54		// Text descriptions surface in the Preferences Sort by... options
55		SEQUENCE_AND_LABEL("Sequence"), LABEL_AND_SEQUENCE("Label"),
56		NONE("No sort");
57
58		private String description;
59
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
60	0	private SequenceAnnotationOrder(String s)...
61		{
62	0	description = s;
63		}
64
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
65	0	@Override...
66		public String toString()
67		{
68	0	return description;
69		}
70
		0% Uncovered Elements: 6 (6) Complexity: 2 Complexity Density: 0.5
71	0	public static SequenceAnnotationOrder forDescription(String d)...
72		{
73	0	for (SequenceAnnotationOrder order : values())
74		{
75	0	if (order.toString().equals(d))
76		{
77	0	return order;
78		}
79		}
80	0	return null;
81		}
82		}
83
84		// the alignment with respect to which annotations are sorted
85		private final AlignmentI alignment;
86
87		// user preference for placement of non-sequence annotations
88		private boolean showAutocalcAbove;
89
90		// working map of sequence index in alignment
91		private final Map<SequenceI, Integer> sequenceIndices = new HashMap<SequenceI, Integer>();
92
93		/**
94		* Constructor given an alignment and the location (top or bottom) of
95		* Consensus and similar.
96		*
97		* @param alignmentI
98		* @param showAutocalculatedAbove
99		*/
		0% Uncovered Elements: 2 (2) Complexity: 1 Complexity Density: 0.5
100	0	public AnnotationSorter(AlignmentI alignmentI,...
101		boolean showAutocalculatedAbove)
102		{
103	0	this.alignment = alignmentI;
104	0	this.showAutocalcAbove = showAutocalculatedAbove;
105		}
106
107		/**
108		* Default comparator sorts as follows by annotation type within sequence
109		* order:
110		* <ul>
111		* <li>annotations with a reference to a sequence in the alignment are sorted
112		* on sequence ordering</li>
113		* <li>other annotations go 'at the end', with their mutual order
114		* unchanged</li>
115		* <li>within the same sequence ref, sort by label (non-case-sensitive)</li>
116		* </ul>
117		*/
118		private final Comparator<? super AlignmentAnnotation> bySequenceAndLabel = new Comparator<AlignmentAnnotation>()
119		{
		0% Uncovered Elements: 40 (40) Complexity: 13 Complexity Density: 0.65
120	0	@Override...
121		public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2)
122		{
123	0	if (o1 == null && o2 == null)
124		{
125	0	return 0;
126		}
127	0	if (o1 == null)
128		{
129	0	return -1;
130		}
131	0	if (o2 == null)
132		{
133	0	return 1;
134		}
135
136		// TODO how to treat sequence-related autocalculated annotation
137	0	boolean o1auto = o1.autoCalculated && o1.sequenceRef == null;
138	0	boolean o2auto = o2.autoCalculated && o2.sequenceRef == null;
139		/*
140		* Ignore label (keep existing ordering) for
141		* Conservation/Quality/Consensus etc
142		*/
143	0	if (o1auto && o2auto)
144		{
145	0	return 0;
146		}
147
148		/*
149		* Sort autocalculated before or after sequence-related.
150		*/
151	0	if (o1auto)
152		{
153	0	return showAutocalcAbove ? -1 : 1;
154		}
155	0	if (o2auto)
156		{
157	0	return showAutocalcAbove ? 1 : -1;
158		}
159	0	int computedOrder = compareSequences(o1, o2);
160	0	if (computedOrder == 0)
161		{
162	0	computedOrder = compareLabels(o1, o2);
163		}
164	0	if (computedOrder == 0)
165		{
166	0	computedOrder = compareDescriptions(o1, o2);
167		}
168	0	return computedOrder;
169		}
170
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
171	0	@Override...
172		public String toString()
173		{
174	0	return "Sort by sequence and label";
175		}
176		};
177
178		/**
179		* This comparator sorts as follows by sequence order within annotation type
180		* <ul>
181		* <li>annotations with a reference to a sequence in the alignment are sorted
182		* on label (non-case-sensitive)</li>
183		* <li>other annotations go 'at the end', with their mutual order
184		* unchanged</li>
185		* <li>within the same label, sort by order of the related sequences</li>
186		* </ul>
187		*/
188		private final Comparator<? super AlignmentAnnotation> byLabelAndSequence = new Comparator<AlignmentAnnotation>()
189		{
		0% Uncovered Elements: 34 (34) Complexity: 12 Complexity Density: 0.75
190	0	@Override...
191		public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2)
192		{
193	0	if (o1 == null && o2 == null)
194		{
195	0	return 0;
196		}
197	0	if (o1 == null)
198		{
199	0	return -1;
200		}
201	0	if (o2 == null)
202		{
203	0	return 1;
204		}
205
206		// TODO how to treat sequence-related autocalculated annotation
207	0	boolean o1auto = o1.autoCalculated && o1.sequenceRef == null;
208	0	boolean o2auto = o2.autoCalculated && o2.sequenceRef == null;
209		/*
210		* Ignore label (keep existing ordering) for
211		* Conservation/Quality/Consensus etc
212		*/
213	0	if (o1auto && o2auto)
214		{
215	0	return 0;
216		}
217
218		/*
219		* Sort autocalculated before or after sequence-related.
220		*/
221	0	if (o1auto)
222		{
223	0	return showAutocalcAbove ? -1 : 1;
224		}
225	0	if (o2auto)
226		{
227	0	return showAutocalcAbove ? 1 : -1;
228		}
229	0	int labelOrder = compareLabels(o1, o2);
230	0	return labelOrder == 0 ? compareSequences(o1, o2) : labelOrder;
231		}
232
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
233	0	@Override...
234		public String toString()
235		{
236	0	return "Sort by label and sequence";
237		}
238		};
239
240		/**
241		* noSort leaves sort order unchanged, within sequence- and autocalculated
242		* annotations, but may switch the ordering of these groups. Note this is
243		* guaranteed (at least in Java 7) as Arrays.sort() is guaranteed to be
244		* 'stable' (not change ordering of equal items).
245		*/
246		private Comparator<? super AlignmentAnnotation> noSort = new Comparator<AlignmentAnnotation>()
247		{
		0% Uncovered Elements: 18 (18) Complexity: 9 Complexity Density: 1.12
248	0	@Override...
249		public int compare(AlignmentAnnotation o1, AlignmentAnnotation o2)
250		{
251		// TODO how to treat sequence-related autocalculated annotation
252	0	boolean o1auto = o1.autoCalculated && o1.sequenceRef == null;
253	0	boolean o2auto = o2.autoCalculated && o2.sequenceRef == null;
254		// TODO skip this test to allow customised ordering of all annotations
255		// - needs a third option: place autocalculated first / last / none
256	0	if (o1 != null && o2 != null)
257		{
258	0	if (o1auto && !o2auto)
259		{
260	0	return showAutocalcAbove ? -1 : 1;
261		}
262	0	if (!o1auto && o2auto)
263		{
264	0	return showAutocalcAbove ? 1 : -1;
265		}
266		}
267	0	return 0;
268		}
269
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
270	0	@Override...
271		public String toString()
272		{
273	0	return "No sort";
274		}
275		};
276
277		/**
278		* Sort by the specified ordering of sequence-specific annotations.
279		*
280		* @param alignmentAnnotations
281		* @param order
282		*/
		0% Uncovered Elements: 11 (11) Complexity: 3 Complexity Density: 0.43
283	0	public void sort(AlignmentAnnotation[] alignmentAnnotations,...
284		SequenceAnnotationOrder order)
285		{
286	0	if (alignmentAnnotations == null)
287		{
288	0	return;
289		}
290		// cache 'alignment sequence position' for the annotations
291	0	saveSequenceIndices(alignmentAnnotations);
292
293	0	Comparator<? super AlignmentAnnotation> comparator = getComparator(
294		order);
295
296	0	if (alignmentAnnotations != null)
297		{
298	0	synchronized (alignmentAnnotations)
299		{
300	0	Arrays.sort(alignmentAnnotations, comparator);
301		}
302		}
303		}
304
305		/**
306		* Calculate and save in a temporary map the position of each annotation's
307		* sequence (if it has one) in the alignment. Faster to do this once than for
308		* every annotation comparison.
309		*
310		* @param alignmentAnnotations
311		*/
		0% Uncovered Elements: 8 (8) Complexity: 2 Complexity Density: 0.33
312	0	private void saveSequenceIndices(...
313		AlignmentAnnotation[] alignmentAnnotations)
314		{
315	0	sequenceIndices.clear();
316	0	for (AlignmentAnnotation ann : alignmentAnnotations)
317		{
318	0	SequenceI seq = ann.sequenceRef;
319	0	if (seq != null)
320		{
321	0	int index = AlignmentUtils.getSequenceIndex(alignment, seq);
322	0	sequenceIndices.put(seq, index);
323		}
324		}
325		}
326
327		/**
328		* Get the comparator for the specified sort order.
329		*
330		* @param order
331		* @return
332		*/
		0% Uncovered Elements: 13 (13) Complexity: 5 Complexity Density: 0.45
333	0	private Comparator<? super AlignmentAnnotation> getComparator(...
334		SequenceAnnotationOrder order)
335		{
336	0	if (order == null)
337		{
338	0	return noSort;
339		}
340	0	switch (order)
341		{
342	0	case NONE:
343	0	return this.noSort;
344	0	case SEQUENCE_AND_LABEL:
345	0	return this.bySequenceAndLabel;
346	0	case LABEL_AND_SEQUENCE:
347	0	return this.byLabelAndSequence;
348	0	default:
349	0	throw new UnsupportedOperationException(order.toString());
350		}
351		}
352
353		/**
354		* Non-case-sensitive comparison of annotation labels. Returns zero if either
355		* argument is null.
356		*
357		* @param o1
358		* @param o2
359		* @return
360		*/
		0% Uncovered Elements: 7 (7) Complexity: 3 Complexity Density: 0.6
361	0	private int compareLabels(AlignmentAnnotation o1, AlignmentAnnotation o2)...
362		{
363	0	if (o1 == null || o2 == null)
364		{
365	0	return 0;
366		}
367	0	String label1 = o1.label;
368	0	String label2 = o2.label;
369	0	return compareString(label1, label2);
370		}
371
372		/**
373		* Non-case-sensitive comparison of annotation descriptions. Returns zero if
374		* either argument is null.
375		*
376		* @param o1
377		* @param o2
378		* @return
379		*/
		0% Uncovered Elements: 7 (7) Complexity: 3 Complexity Density: 0.6
380	0	private int compareDescriptions(AlignmentAnnotation o1,...
381		AlignmentAnnotation o2)
382		{
383	0	if (o1 == null || o2 == null)
384		{
385	0	return 0;
386		}
387	0	String label1 = o1.description;
388	0	String label2 = o2.description;
389	0	return compareString(label1, label2);
390		}
391
		0% Uncovered Elements: 13 (13) Complexity: 5 Complexity Density: 0.71
392	0	private int compareString(String label1, String label2)...
393		{
394	0	if (label1 == null && label2 == null)
395		{
396	0	return 0;
397		}
398	0	if (label1 == null)
399		{
400	0	return -1;
401		}
402	0	if (label2 == null)
403		{
404	0	return 1;
405		}
406	0	return label1.toUpperCase(Locale.ROOT)
407		.compareTo(label2.toUpperCase(Locale.ROOT));
408		}
409
410		/**
411		* Comparison based on position of associated sequence (if any) in the
412		* alignment. Returns zero if either argument is null.
413		*
414		* @param o1
415		* @param o2
416		* @return
417		*/
		0% Uncovered Elements: 33 (33) Complexity: 10 Complexity Density: 0.59
418	0	private int compareSequences(AlignmentAnnotation o1,...
419		AlignmentAnnotation o2)
420		{
421	0	SequenceI seq1 = o1.sequenceRef;
422	0	SequenceI seq2 = o2.sequenceRef;
423	0	if (seq1 == null && seq2 == null)
424		{
425	0	return 0;
426		}
427		/*
428		* Sort non-sequence-related before or after sequence-related.
429		*/
430	0	if (seq1 == null)
431		{
432	0	return showAutocalcAbove ? -1 : 1;
433		}
434	0	if (seq2 == null)
435		{
436	0	return showAutocalcAbove ? 1 : -1;
437		}
438		// get sequence index - but note -1 means 'at end' so needs special handling
439	0	int index1 = sequenceIndices.get(seq1);
440	0	int index2 = sequenceIndices.get(seq2);
441	0	if (index1 == index2)
442		{
443	0	return 0;
444		}
445	0	if (index1 == -1)
446		{
447	0	return -1;
448		}
449	0	if (index2 == -1)
450		{
451	0	return 1;
452		}
453	0	return Integer.compare(index1, index2);
454		}
455		}