1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
package jalview.datamodel; |
22 |
|
|
23 |
|
import jalview.util.MapList; |
24 |
|
import jalview.util.MappingUtils; |
25 |
|
|
26 |
|
import java.util.AbstractList; |
27 |
|
import java.util.ArrayList; |
28 |
|
import java.util.List; |
29 |
|
|
30 |
|
|
31 |
|
|
32 |
|
|
33 |
|
|
|
|
| 85.3% |
Uncovered Elements: 44 (300) |
Complexity: 96 |
Complexity Density: 0.55 |
|
34 |
|
public class AlignedCodonFrame |
35 |
|
{ |
36 |
|
|
37 |
|
|
38 |
|
|
39 |
|
|
|
|
| 58.3% |
Uncovered Elements: 10 (24) |
Complexity: 9 |
Complexity Density: 0.75 |
|
40 |
|
public class SequenceToSequenceMapping |
41 |
|
{ |
42 |
|
private SequenceI fromSeq; |
43 |
|
|
44 |
|
private Mapping mapping; |
45 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
46 |
377 |
SequenceToSequenceMapping(SequenceI from, Mapping map)... |
47 |
|
{ |
48 |
377 |
this.fromSeq = from; |
49 |
377 |
this.mapping = map; |
50 |
|
} |
51 |
|
|
52 |
|
|
53 |
|
|
54 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
55 |
0 |
@Override... |
56 |
|
public String toString() |
57 |
|
{ |
58 |
0 |
return String.format("From %s %s", fromSeq.getName(), |
59 |
|
mapping.toString()); |
60 |
|
} |
61 |
|
|
62 |
|
|
63 |
|
|
64 |
|
|
65 |
|
@see |
66 |
|
|
|
|
| 0% |
Uncovered Elements: 3 (3) |
Complexity: 2 |
Complexity Density: 2 |
|
67 |
0 |
@Override... |
68 |
|
public int hashCode() |
69 |
|
{ |
70 |
0 |
return (fromSeq == null ? 0 : fromSeq.hashCode() * 31) |
71 |
|
+ mapping.hashCode(); |
72 |
|
} |
73 |
|
|
74 |
|
|
75 |
|
|
76 |
|
|
77 |
|
|
78 |
|
@see |
79 |
|
|
|
|
| 60% |
Uncovered Elements: 4 (10) |
Complexity: 3 |
Complexity Density: 0.5 |
|
80 |
150 |
@Override... |
81 |
|
public boolean equals(Object obj) |
82 |
|
{ |
83 |
150 |
if (!(obj instanceof SequenceToSequenceMapping)) |
84 |
|
{ |
85 |
0 |
return false; |
86 |
|
} |
87 |
150 |
SequenceToSequenceMapping that = (SequenceToSequenceMapping) obj; |
88 |
150 |
if (this.mapping == null) |
89 |
|
{ |
90 |
0 |
return that.mapping == null; |
91 |
|
} |
92 |
|
|
93 |
150 |
return (this.fromSeq == that.fromSeq |
94 |
|
|| (this.fromSeq != null && that.fromSeq != null |
95 |
|
&& this.fromSeq.getDatasetSequence() != null |
96 |
|
&& this.fromSeq.getDatasetSequence() == that.fromSeq |
97 |
|
.getDatasetSequence())) |
98 |
|
&& this.mapping.equals(that.mapping); |
99 |
|
} |
100 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
101 |
14 |
public SequenceI getFromSeq()... |
102 |
|
{ |
103 |
14 |
return fromSeq; |
104 |
|
} |
105 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
106 |
28 |
public Mapping getMapping()... |
107 |
|
{ |
108 |
28 |
return mapping; |
109 |
|
} |
110 |
|
} |
111 |
|
|
112 |
|
private List<SequenceToSequenceMapping> mappings; |
113 |
|
|
114 |
|
|
115 |
|
|
116 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
117 |
165 |
public AlignedCodonFrame()... |
118 |
|
{ |
119 |
165 |
mappings = new ArrayList<SequenceToSequenceMapping>(); |
120 |
|
} |
121 |
|
|
122 |
|
|
123 |
|
|
124 |
|
|
125 |
|
|
126 |
|
@param |
127 |
|
@param |
128 |
|
@param |
129 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
130 |
383 |
public void addMap(SequenceI dnaseq, SequenceI aaseq, MapList map)... |
131 |
|
{ |
132 |
383 |
addMap(dnaseq, aaseq, map, null); |
133 |
|
} |
134 |
|
|
135 |
|
|
136 |
|
|
137 |
|
|
138 |
|
|
139 |
|
@param |
140 |
|
@param |
141 |
|
@param |
142 |
|
@param |
143 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (15) |
Complexity: 5 |
Complexity Density: 0.56 |
|
144 |
385 |
public void addMap(SequenceI dnaseq, SequenceI aaseq, MapList map,... |
145 |
|
String mapFromId) |
146 |
|
{ |
147 |
|
|
148 |
|
|
149 |
|
|
150 |
|
|
151 |
385 |
SequenceI fromSeq = (dnaseq.getDatasetSequence() == null) ? dnaseq |
152 |
|
: dnaseq.getDatasetSequence(); |
153 |
385 |
SequenceI toSeq = (aaseq.getDatasetSequence() == null) ? aaseq |
154 |
|
: aaseq.getDatasetSequence(); |
155 |
|
|
156 |
|
|
157 |
|
|
158 |
|
|
159 |
|
|
160 |
|
|
161 |
385 |
for (SequenceToSequenceMapping ssm : mappings) |
162 |
|
{ |
163 |
1125 |
if (ssm.fromSeq == fromSeq && ssm.mapping.to == toSeq) |
164 |
|
{ |
165 |
8 |
ssm.mapping.map.addMapList(map); |
166 |
8 |
return; |
167 |
|
} |
168 |
|
} |
169 |
|
|
170 |
|
|
171 |
|
|
172 |
|
|
173 |
377 |
Mapping mp = new Mapping(toSeq, map); |
174 |
377 |
mp.setMappedFromId(mapFromId); |
175 |
377 |
mappings.add(new SequenceToSequenceMapping(fromSeq, mp)); |
176 |
|
} |
177 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0.25 |
|
178 |
44 |
public SequenceI[] getdnaSeqs()... |
179 |
|
{ |
180 |
|
|
181 |
|
|
182 |
44 |
List<SequenceI> seqs = new ArrayList<SequenceI>(); |
183 |
44 |
for (SequenceToSequenceMapping ssm : mappings) |
184 |
|
{ |
185 |
52 |
seqs.add(ssm.fromSeq); |
186 |
|
} |
187 |
44 |
return seqs.toArray(new SequenceI[seqs.size()]); |
188 |
|
} |
189 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0.25 |
|
190 |
16 |
public SequenceI[] getAaSeqs()... |
191 |
|
{ |
192 |
|
|
193 |
16 |
List<SequenceI> seqs = new ArrayList<SequenceI>(); |
194 |
16 |
for (SequenceToSequenceMapping ssm : mappings) |
195 |
|
{ |
196 |
16 |
seqs.add(ssm.mapping.to); |
197 |
|
} |
198 |
16 |
return seqs.toArray(new SequenceI[seqs.size()]); |
199 |
|
} |
200 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0.25 |
|
201 |
44 |
public MapList[] getdnaToProt()... |
202 |
|
{ |
203 |
44 |
List<MapList> maps = new ArrayList<MapList>(); |
204 |
44 |
for (SequenceToSequenceMapping ssm : mappings) |
205 |
|
{ |
206 |
44 |
maps.add(ssm.mapping.map); |
207 |
|
} |
208 |
44 |
return maps.toArray(new MapList[maps.size()]); |
209 |
|
} |
210 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0.25 |
|
211 |
8 |
public Mapping[] getProtMappings()... |
212 |
|
{ |
213 |
8 |
List<Mapping> maps = new ArrayList<Mapping>(); |
214 |
8 |
for (SequenceToSequenceMapping ssm : mappings) |
215 |
|
{ |
216 |
9 |
maps.add(ssm.mapping); |
217 |
|
} |
218 |
8 |
return maps.toArray(new Mapping[maps.size()]); |
219 |
|
} |
220 |
|
|
221 |
|
|
222 |
|
|
223 |
|
|
224 |
|
|
225 |
|
@param |
226 |
|
@return |
227 |
|
|
|
|
| 80% |
Uncovered Elements: 2 (10) |
Complexity: 4 |
Complexity Density: 0.67 |
|
228 |
10 |
public Mapping getMappingForSequence(SequenceI seq)... |
229 |
|
{ |
230 |
10 |
SequenceI seqDs = seq.getDatasetSequence(); |
231 |
10 |
seqDs = seqDs != null ? seqDs : seq; |
232 |
|
|
233 |
10 |
for (SequenceToSequenceMapping ssm : mappings) |
234 |
|
{ |
235 |
18 |
if (ssm.fromSeq == seqDs || ssm.mapping.to == seqDs) |
236 |
|
{ |
237 |
10 |
return ssm.mapping; |
238 |
|
} |
239 |
|
} |
240 |
0 |
return null; |
241 |
|
} |
242 |
|
|
243 |
|
|
244 |
|
|
245 |
|
|
246 |
|
|
247 |
|
@param |
248 |
|
@return |
249 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 3 |
Complexity Density: 0.6 |
|
250 |
341 |
public SequenceI getAaForDnaSeq(SequenceI dnaSeqRef)... |
251 |
|
{ |
252 |
341 |
SequenceI dnads = dnaSeqRef.getDatasetSequence(); |
253 |
341 |
for (SequenceToSequenceMapping ssm : mappings) |
254 |
|
{ |
255 |
372 |
if (ssm.fromSeq == dnaSeqRef || ssm.fromSeq == dnads) |
256 |
|
{ |
257 |
89 |
return ssm.mapping.to; |
258 |
|
} |
259 |
|
} |
260 |
252 |
return null; |
261 |
|
} |
262 |
|
|
263 |
|
|
264 |
|
|
265 |
|
@param |
266 |
|
@return |
267 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 3 |
Complexity Density: 0.6 |
|
268 |
276 |
public SequenceI getDnaForAaSeq(SequenceI aaSeqRef)... |
269 |
|
{ |
270 |
276 |
SequenceI aads = aaSeqRef.getDatasetSequence(); |
271 |
276 |
for (SequenceToSequenceMapping ssm : mappings) |
272 |
|
{ |
273 |
305 |
if (ssm.mapping.to == aaSeqRef || ssm.mapping.to == aads) |
274 |
|
{ |
275 |
89 |
return ssm.fromSeq; |
276 |
|
} |
277 |
|
} |
278 |
187 |
return null; |
279 |
|
} |
280 |
|
|
281 |
|
|
282 |
|
|
283 |
|
|
284 |
|
@param |
285 |
|
|
286 |
|
@return |
287 |
|
|
288 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
289 |
328 |
public boolean involvesSequence(SequenceI seq)... |
290 |
|
{ |
291 |
328 |
return getAaForDnaSeq(seq) != null || getDnaForAaSeq(seq) != null; |
292 |
|
} |
293 |
|
|
294 |
|
|
295 |
|
|
296 |
|
|
297 |
|
|
298 |
|
@param |
299 |
|
@param |
300 |
|
|
301 |
|
@param |
302 |
|
|
303 |
|
|
|
|
| 96% |
Uncovered Elements: 1 (25) |
Complexity: 9 |
Complexity Density: 0.69 |
|
304 |
113 |
public void markMappedRegion(SequenceI seq, int index,... |
305 |
|
SearchResultsI results) |
306 |
|
{ |
307 |
113 |
int[] codon; |
308 |
113 |
SequenceI ds = seq.getDatasetSequence(); |
309 |
113 |
for (SequenceToSequenceMapping ssm : mappings) |
310 |
|
{ |
311 |
257 |
if (ssm.fromSeq == seq || ssm.fromSeq == ds) |
312 |
|
{ |
313 |
54 |
codon = ssm.mapping.map.locateInTo(index, index); |
314 |
54 |
if (codon != null) |
315 |
|
{ |
316 |
90 |
for (int i = 0; i < codon.length; i += 2) |
317 |
|
{ |
318 |
45 |
results.addResult(ssm.mapping.to, codon[i], codon[i + 1]); |
319 |
|
} |
320 |
|
} |
321 |
|
} |
322 |
203 |
else if (ssm.mapping.to == seq || ssm.mapping.to == ds) |
323 |
|
{ |
324 |
|
{ |
325 |
59 |
codon = ssm.mapping.map.locateInFrom(index, index); |
326 |
59 |
if (codon != null) |
327 |
|
{ |
328 |
133 |
for (int i = 0; i < codon.length; i += 2) |
329 |
|
{ |
330 |
74 |
results.addResult(ssm.fromSeq, codon[i], codon[i + 1]); |
331 |
|
} |
332 |
|
} |
333 |
|
} |
334 |
|
} |
335 |
|
} |
336 |
|
} |
337 |
|
|
338 |
|
|
339 |
|
|
340 |
|
|
341 |
|
|
342 |
|
|
343 |
|
|
344 |
|
|
345 |
|
|
346 |
|
|
347 |
|
@param |
348 |
|
|
349 |
|
@param |
350 |
|
|
351 |
|
@return |
352 |
|
|
|
|
| 0% |
Uncovered Elements: 12 (12) |
Complexity: 3 |
Complexity Density: 0.38 |
|
353 |
0 |
public int[] getDnaPosition(SequenceI seq, int aaPos)... |
354 |
|
{ |
355 |
|
|
356 |
|
|
357 |
|
|
358 |
0 |
MapList ml = null; |
359 |
0 |
int i = 0; |
360 |
0 |
for (SequenceToSequenceMapping ssm : mappings) |
361 |
|
{ |
362 |
0 |
if (ssm.fromSeq == seq) |
363 |
|
{ |
364 |
0 |
ml = getdnaToProt()[i]; |
365 |
0 |
break; |
366 |
|
} |
367 |
0 |
i++; |
368 |
|
} |
369 |
0 |
return ml == null ? null : ml.locateInFrom(aaPos, aaPos); |
370 |
|
} |
371 |
|
|
372 |
|
|
373 |
|
|
374 |
|
|
375 |
|
|
376 |
|
|
377 |
|
@param |
378 |
|
|
379 |
|
@param |
380 |
|
@return |
381 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (19) |
Complexity: 8 |
Complexity Density: 0.73 |
|
382 |
31 |
public SequenceI findAlignedSequence(SequenceI seq, AlignmentI al)... |
383 |
|
{ |
384 |
|
|
385 |
|
|
386 |
|
|
387 |
31 |
for (SequenceToSequenceMapping ssm : mappings) |
388 |
|
{ |
389 |
43 |
if (ssm.fromSeq == seq || ssm.fromSeq == seq.getDatasetSequence()) |
390 |
|
{ |
391 |
21 |
for (SequenceI sourceAligned : al.getSequences()) |
392 |
|
{ |
393 |
28 |
if (ssm.mapping.to == sourceAligned.getDatasetSequence() |
394 |
|
|| ssm.mapping.to == sourceAligned) |
395 |
|
{ |
396 |
17 |
return sourceAligned; |
397 |
|
} |
398 |
|
} |
399 |
|
} |
400 |
|
} |
401 |
|
|
402 |
|
|
403 |
|
|
404 |
|
|
405 |
14 |
for (SequenceToSequenceMapping ssm : mappings) |
406 |
|
{ |
407 |
15 |
if (ssm.mapping.to == seq |
408 |
|
|| ssm.mapping.to == seq.getDatasetSequence()) |
409 |
|
{ |
410 |
9 |
for (SequenceI sourceAligned : al.getSequences()) |
411 |
|
{ |
412 |
11 |
if (ssm.fromSeq == sourceAligned.getDatasetSequence()) |
413 |
|
{ |
414 |
9 |
return sourceAligned; |
415 |
|
} |
416 |
|
} |
417 |
|
} |
418 |
|
} |
419 |
|
|
420 |
5 |
return null; |
421 |
|
} |
422 |
|
|
423 |
|
|
424 |
|
|
425 |
|
|
426 |
|
|
427 |
|
|
428 |
|
@param |
429 |
|
@param |
430 |
|
@param |
431 |
|
@return |
432 |
|
|
|
|
| 85.7% |
Uncovered Elements: 4 (28) |
Complexity: 11 |
Complexity Density: 0.79 |
|
433 |
157 |
public int[] getMappedRegion(SequenceI target, SequenceI query,... |
434 |
|
int queryPos) |
435 |
|
{ |
436 |
157 |
SequenceI targetDs = target.getDatasetSequence() == null ? target |
437 |
|
: target.getDatasetSequence(); |
438 |
157 |
SequenceI queryDs = query.getDatasetSequence() == null ? query |
439 |
|
: query.getDatasetSequence(); |
440 |
157 |
if (targetDs == null || queryDs == null ) |
441 |
|
{ |
442 |
0 |
return null; |
443 |
|
} |
444 |
157 |
for (SequenceToSequenceMapping ssm : mappings) |
445 |
|
{ |
446 |
|
|
447 |
|
|
448 |
|
|
449 |
167 |
if (ssm.fromSeq == targetDs && ssm.mapping.to == queryDs) |
450 |
|
{ |
451 |
40 |
int[] codon = ssm.mapping.map.locateInFrom(queryPos, queryPos); |
452 |
40 |
if (codon != null) |
453 |
|
{ |
454 |
36 |
return codon; |
455 |
|
} |
456 |
|
} |
457 |
|
|
458 |
|
|
459 |
|
|
460 |
127 |
else if (ssm.fromSeq == queryDs && ssm.mapping.to == targetDs) |
461 |
|
{ |
462 |
115 |
int[] codon = ssm.mapping.map.locateInTo(queryPos, queryPos); |
463 |
115 |
if (codon != null) |
464 |
|
{ |
465 |
23 |
return codon; |
466 |
|
} |
467 |
|
} |
468 |
|
} |
469 |
98 |
return null; |
470 |
|
} |
471 |
|
|
472 |
|
|
473 |
|
|
474 |
|
|
475 |
|
|
476 |
|
|
477 |
|
|
478 |
|
@param |
479 |
|
|
480 |
|
@param |
481 |
|
|
482 |
|
@return |
483 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (23) |
Complexity: 5 |
Complexity Density: 0.29 |
|
484 |
53 |
public List<char[]> getMappedCodons(SequenceI protein, int aaPos)... |
485 |
|
{ |
486 |
53 |
MapList ml = null; |
487 |
53 |
SequenceI dnaSeq = null; |
488 |
53 |
List<char[]> result = new ArrayList<char[]>(); |
489 |
|
|
490 |
53 |
for (SequenceToSequenceMapping ssm : mappings) |
491 |
|
{ |
492 |
55 |
if (ssm.mapping.to == protein |
493 |
|
&& ssm.mapping.getMap().getFromRatio() == 3) |
494 |
|
{ |
495 |
29 |
ml = ssm.mapping.map; |
496 |
29 |
dnaSeq = ssm.fromSeq; |
497 |
|
|
498 |
29 |
int[] codonPos = ml.locateInFrom(aaPos, aaPos); |
499 |
29 |
if (codonPos == null) |
500 |
|
{ |
501 |
17 |
return null; |
502 |
|
} |
503 |
|
|
504 |
|
|
505 |
|
|
506 |
|
|
507 |
12 |
codonPos = MappingUtils.flattenRanges(codonPos); |
508 |
12 |
int start = dnaSeq.getStart(); |
509 |
12 |
char c1 = dnaSeq.getCharAt(codonPos[0] - start); |
510 |
12 |
char c2 = dnaSeq.getCharAt(codonPos[1] - start); |
511 |
12 |
char c3 = dnaSeq.getCharAt(codonPos[2] - start); |
512 |
12 |
result.add(new char[] { c1, c2, c3 }); |
513 |
|
} |
514 |
|
} |
515 |
36 |
return result.isEmpty() ? null : result; |
516 |
|
} |
517 |
|
|
518 |
|
|
519 |
|
|
520 |
|
|
521 |
|
|
522 |
|
@param |
523 |
|
@return |
524 |
|
|
|
|
| 82.4% |
Uncovered Elements: 3 (17) |
Complexity: 4 |
Complexity Density: 0.36 |
|
525 |
13 |
public List<Mapping> getMappingsFromSequence(SequenceI seq)... |
526 |
|
{ |
527 |
13 |
List<Mapping> result = new ArrayList<Mapping>(); |
528 |
13 |
List<SequenceI> related = new ArrayList<SequenceI>(); |
529 |
13 |
SequenceI seqDs = seq.getDatasetSequence(); |
530 |
13 |
seqDs = seqDs != null ? seqDs : seq; |
531 |
|
|
532 |
13 |
for (SequenceToSequenceMapping ssm : mappings) |
533 |
|
{ |
534 |
15 |
final Mapping mapping = ssm.mapping; |
535 |
15 |
if (ssm.fromSeq == seqDs) |
536 |
|
{ |
537 |
15 |
if (!related.contains(mapping.to)) |
538 |
|
{ |
539 |
15 |
result.add(mapping); |
540 |
15 |
related.add(mapping.to); |
541 |
|
} |
542 |
|
} |
543 |
|
} |
544 |
13 |
return result; |
545 |
|
} |
546 |
|
|
547 |
|
|
548 |
|
|
549 |
|
|
550 |
|
|
551 |
|
@param |
552 |
|
@param |
553 |
|
@return |
554 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
555 |
7 |
public boolean isRealisableWith(SequenceI seq)... |
556 |
|
{ |
557 |
7 |
return realiseWith(seq, false) > 0; |
558 |
|
} |
559 |
|
|
560 |
|
|
561 |
|
|
562 |
|
|
563 |
|
|
564 |
|
@param |
565 |
|
@return |
566 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
567 |
2 |
public int realiseWith(SequenceI seq)... |
568 |
|
{ |
569 |
2 |
return realiseWith(seq, true); |
570 |
|
} |
571 |
|
|
572 |
|
|
573 |
|
|
574 |
|
|
575 |
|
|
576 |
|
@param |
577 |
|
|
578 |
|
@param |
579 |
|
|
580 |
|
@return |
581 |
|
|
|
|
| 78.9% |
Uncovered Elements: 8 (38) |
Complexity: 8 |
Complexity Density: 0.31 |
|
582 |
9 |
protected int realiseWith(SequenceI seq, boolean doUpdate)... |
583 |
|
{ |
584 |
9 |
SequenceI ds = seq.getDatasetSequence() != null |
585 |
|
? seq.getDatasetSequence() |
586 |
|
: seq; |
587 |
9 |
int count = 0; |
588 |
|
|
589 |
|
|
590 |
|
|
591 |
|
|
592 |
9 |
for (SequenceToSequenceMapping ssm : mappings) |
593 |
|
{ |
594 |
10 |
SequenceI dna = ssm.fromSeq; |
595 |
10 |
if (dna instanceof SequenceDummy |
596 |
|
&& dna.getName().equals(ds.getName())) |
597 |
|
{ |
598 |
8 |
Mapping mapping = ssm.mapping; |
599 |
8 |
int mapStart = mapping.getMap().getFromLowest(); |
600 |
8 |
int mapEnd = mapping.getMap().getFromHighest(); |
601 |
8 |
boolean mappable = couldRealiseSequence(dna, ds, mapStart, mapEnd); |
602 |
8 |
if (mappable) |
603 |
|
{ |
604 |
6 |
count++; |
605 |
6 |
if (doUpdate) |
606 |
|
{ |
607 |
|
|
608 |
|
|
609 |
3 |
ds.setSequenceFeatures(dna.getSequenceFeatures()); |
610 |
|
|
611 |
3 |
ssm.fromSeq = ds; |
612 |
3 |
System.out.println("Realised mapped sequence " + ds.getName()); |
613 |
|
} |
614 |
|
} |
615 |
|
} |
616 |
|
|
617 |
|
|
618 |
|
|
619 |
|
|
620 |
10 |
Mapping mapping = ssm.mapping; |
621 |
10 |
SequenceI prot = mapping.getTo(); |
622 |
10 |
int mapStart = mapping.getMap().getToLowest(); |
623 |
10 |
int mapEnd = mapping.getMap().getToHighest(); |
624 |
10 |
boolean mappable = couldRealiseSequence(prot, ds, mapStart, mapEnd); |
625 |
10 |
if (mappable) |
626 |
|
{ |
627 |
0 |
count++; |
628 |
0 |
if (doUpdate) |
629 |
|
{ |
630 |
|
|
631 |
|
|
632 |
0 |
ds.setSequenceFeatures(dna.getSequenceFeatures()); |
633 |
0 |
ssm.mapping.setTo(ds); |
634 |
|
} |
635 |
|
} |
636 |
|
} |
637 |
9 |
return count; |
638 |
|
} |
639 |
|
|
640 |
|
|
641 |
|
|
642 |
|
|
643 |
|
|
644 |
|
|
645 |
|
@param |
646 |
|
@param |
647 |
|
@param |
648 |
|
@param |
649 |
|
@return |
650 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 5 |
Complexity Density: 0.71 |
|
651 |
28 |
protected static boolean couldRealiseSequence(SequenceI existing,... |
652 |
|
SequenceI replacement, int mapStart, int mapEnd) |
653 |
|
{ |
654 |
28 |
if (existing instanceof SequenceDummy |
655 |
|
&& !(replacement instanceof SequenceDummy) |
656 |
|
&& existing.getName().equals(replacement.getName())) |
657 |
|
{ |
658 |
13 |
int start = replacement.getStart(); |
659 |
13 |
int end = replacement.getEnd(); |
660 |
13 |
boolean mappingOverlapsSequence = (mapStart >= start |
661 |
|
&& mapStart <= end) || (mapEnd >= start && mapEnd <= end); |
662 |
13 |
if (mappingOverlapsSequence) |
663 |
|
{ |
664 |
9 |
return true; |
665 |
|
} |
666 |
|
} |
667 |
19 |
return false; |
668 |
|
} |
669 |
|
|
670 |
|
|
671 |
|
|
672 |
|
|
673 |
|
|
674 |
|
|
675 |
|
@param |
676 |
|
|
|
|
| 85.7% |
Uncovered Elements: 2 (14) |
Complexity: 5 |
Complexity Density: 0.62 |
|
677 |
8 |
public void updateToDataset(SequenceI seq)... |
678 |
|
{ |
679 |
8 |
if (seq == null || seq.getDatasetSequence() == null) |
680 |
|
{ |
681 |
0 |
return; |
682 |
|
} |
683 |
8 |
SequenceI ds = seq.getDatasetSequence(); |
684 |
|
|
685 |
8 |
for (SequenceToSequenceMapping ssm : mappings) |
686 |
|
|
687 |
|
|
688 |
|
|
689 |
|
{ |
690 |
8 |
if (ssm.fromSeq == seq) |
691 |
|
{ |
692 |
4 |
ssm.fromSeq = ds; |
693 |
|
} |
694 |
|
|
695 |
|
|
696 |
|
|
697 |
|
|
698 |
8 |
if (ssm.mapping.to == seq) |
699 |
|
{ |
700 |
4 |
ssm.mapping.to = ds; |
701 |
|
} |
702 |
|
} |
703 |
|
} |
704 |
|
|
705 |
|
|
706 |
|
|
707 |
|
|
708 |
|
@return |
709 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
710 |
6 |
public boolean isEmpty()... |
711 |
|
{ |
712 |
6 |
return mappings.isEmpty(); |
713 |
|
} |
714 |
|
|
715 |
|
|
716 |
|
|
717 |
|
|
|
|
| 0% |
Uncovered Elements: 3 (3) |
Complexity: 2 |
Complexity Density: 2 |
|
718 |
0 |
@Override... |
719 |
|
public String toString() |
720 |
|
{ |
721 |
0 |
return mappings == null ? "null" : mappings.toString(); |
722 |
|
} |
723 |
|
|
724 |
|
|
725 |
|
|
726 |
|
|
727 |
|
|
728 |
|
@param |
729 |
|
|
730 |
|
@param |
731 |
|
|
732 |
|
@return |
733 |
|
|
|
|
| 78.6% |
Uncovered Elements: 3 (14) |
Complexity: 7 |
Complexity Density: 0.88 |
|
734 |
9 |
public Mapping getMappingBetween(SequenceI fromSeq, SequenceI toSeq)... |
735 |
|
{ |
736 |
9 |
SequenceI dssFrom = fromSeq.getDatasetSequence() == null ? fromSeq |
737 |
|
: fromSeq.getDatasetSequence(); |
738 |
9 |
SequenceI dssTo = toSeq.getDatasetSequence() == null ? toSeq |
739 |
|
: toSeq.getDatasetSequence(); |
740 |
|
|
741 |
9 |
for (SequenceToSequenceMapping mapping : mappings) |
742 |
|
{ |
743 |
12 |
SequenceI from = mapping.fromSeq; |
744 |
12 |
SequenceI to = mapping.mapping.to; |
745 |
12 |
if ((from == dssFrom && to == dssTo) |
746 |
|
|| (from == dssTo && to == dssFrom)) |
747 |
|
{ |
748 |
9 |
return mapping.mapping; |
749 |
|
} |
750 |
|
} |
751 |
0 |
return null; |
752 |
|
} |
753 |
|
|
754 |
|
|
755 |
|
|
756 |
|
|
757 |
|
@see |
758 |
|
@see |
759 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
760 |
0 |
@Override... |
761 |
|
public int hashCode() |
762 |
|
{ |
763 |
0 |
return this.mappings.hashCode(); |
764 |
|
} |
765 |
|
|
766 |
|
|
767 |
|
|
768 |
|
|
769 |
|
|
770 |
|
@see |
771 |
|
|
|
|
| 60% |
Uncovered Elements: 2 (5) |
Complexity: 2 |
Complexity Density: 0.67 |
|
772 |
196 |
@Override... |
773 |
|
public boolean equals(Object obj) |
774 |
|
{ |
775 |
196 |
if (!(obj instanceof AlignedCodonFrame)) |
776 |
|
{ |
777 |
0 |
return false; |
778 |
|
} |
779 |
196 |
return this.mappings.equals(((AlignedCodonFrame) obj).mappings); |
780 |
|
} |
781 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
782 |
28 |
public List<SequenceToSequenceMapping> getMappings()... |
783 |
|
{ |
784 |
28 |
return mappings; |
785 |
|
} |
786 |
|
} |