+
+ /**
+ * Returns a hashCode derived from the hashcodes of the mappings and fromSeq
+ *
+ * @see SequenceToSequenceMapping#hashCode()
+ */
+ @Override
+ public int hashCode()
+ {
+ return (fromSeq == null ? 0 : fromSeq.hashCode() * 31)
+ + mapping.hashCode();
+ }
+
+ /**
+ * Answers true if the objects hold the same mapping between the same two
+ * sequences
+ *
+ * @see Mapping#equals
+ */
+ @Override
+ public boolean equals(Object obj)
+ {
+ if (!(obj instanceof SequenceToSequenceMapping))
+ {
+ return false;
+ }
+ SequenceToSequenceMapping that = (SequenceToSequenceMapping) obj;
+ if (this.mapping == null)
+ {
+ return that.mapping == null;
+ }
+ // TODO: can simplify by asserting fromSeq is a dataset sequence
+ return (this.fromSeq == that.fromSeq
+ || (this.fromSeq != null && that.fromSeq != null
+ && this.fromSeq.getDatasetSequence() != null
+ && this.fromSeq.getDatasetSequence() == that.fromSeq
+ .getDatasetSequence()))
+ && this.mapping.equals(that.mapping);
+ }
+
+ public SequenceI getFromSeq()
+ {
+ return fromSeq;
+ }
+
+ public Mapping getMapping()
+ {
+ return mapping;
+ }
+
+ /**
+ * Returns true if the mapping covers the full length of the given sequence.
+ * This allows us to distinguish the CDS that codes for a protein from
+ * another overlapping CDS in the parent dna sequence.
+ *
+ * @param seq
+ * @return
+ */
+ public boolean covers(SequenceI seq)
+ {
+ return covers(seq, false, false);
+ }
+
+ /**
+ *
+ * @param seq
+ * @param localCover
+ * - when true - compare extent of seq's dataset sequence rather
+ * than the local extent
+ * @param either
+ * - when true coverage is required for either seq or the mapped
+ * sequence
+ * @return true if mapping covers full length of given sequence (or the
+ * other if either==true)
+ */
+ public boolean covers(SequenceI seq, boolean localCover, boolean either)
+ {
+ List<int[]> mappedRanges = null, otherRanges = null;
+ MapList mapList = mapping.getMap();
+ int mstart = seq.getStart(), mend = seq.getEnd(), ostart, oend;
+ ;
+ if (fromSeq == seq || fromSeq == seq.getDatasetSequence())
+ {
+ if (localCover && fromSeq != seq)
+ {
+ mstart = fromSeq.getStart();
+ mend = fromSeq.getEnd();
+ }
+ mappedRanges = mapList.getFromRanges();
+ otherRanges = mapList.getToRanges();
+ ostart = mapping.to.getStart();
+ oend = mapping.to.getEnd();
+ }
+ else if (mapping.to == seq || mapping.to == seq.getDatasetSequence())
+ {
+ if (localCover && mapping.to != seq)
+ {
+ mstart = mapping.to.getStart();
+ mend = mapping.to.getEnd();
+ }
+ mappedRanges = mapList.getToRanges();
+ otherRanges = mapList.getFromRanges();
+ ostart = fromSeq.getStart();
+ oend = fromSeq.getEnd();
+ }
+ else
+ {
+ return false;
+ }
+
+ /*
+ * check that each mapped range lies within the sequence range
+ * (necessary for circular CDS - example EMBL:J03321:AAA91567)
+ * and mapped length covers (at least) sequence length
+ */
+ int length = countRange(mappedRanges, mstart, mend);
+
+ if (length != -1)
+ {
+ // add 3 to mapped length to allow for a mapped stop codon
+ if (length + 3 >= (mend - mstart + 1))
+ {
+ return true;
+ }
+ }
+ if (either)
+ {
+ // also check coverage of the other range
+ length = countRange(otherRanges, ostart, oend);
+ if (length != -1)
+ {
+ if (length + 1 >= (oend - ostart + 1))
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ private int countRange(List<int[]> mappedRanges, int mstart, int mend)
+ {
+ int length = 0;
+ for (int[] range : mappedRanges)
+ {
+ int from = Math.min(range[0], range[1]);
+ int to = Math.max(range[0], range[1]);
+ if (from < mstart || to > mend)
+ {
+ return -1;
+ }
+ length += (to - from + 1);
+ }
+ return length;
+ }
+
+ /**
+ * Adds any regions mapped to or from position {@code pos} in sequence
+ * {@code seq} to the given search results Note: recommend first using the
+ * .covers(,true,true) to ensure mapping covers both sequences
+ *
+ * @param seq
+ * @param pos
+ * @param sr
+ */
+ public void markMappedRegion(SequenceI seq, int pos, SearchResultsI sr)
+ {
+ int[] codon = null;
+ SequenceI mappedSeq = null;
+ SequenceI ds = seq.getDatasetSequence();
+ if (ds == null)
+ {
+ ds = seq;
+ }
+
+ if (this.fromSeq == seq || this.fromSeq == ds)
+ {
+ codon = this.mapping.map.locateInTo(pos, pos);
+ mappedSeq = this.mapping.to;
+ }
+ else if (this.mapping.to == seq || this.mapping.to == ds)
+ {
+ codon = this.mapping.map.locateInFrom(pos, pos);
+ mappedSeq = this.fromSeq;
+ }
+
+ if (codon != null)
+ {
+ for (int i = 0; i < codon.length; i += 2)
+ {
+ sr.addResult(mappedSeq, codon[i], codon[i + 1]);
+ }
+ }
+ }