X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=inline;f=src%2Fjalview%2Fdatamodel%2FSearchResults.java;h=546dd6fe229151cb68c55c04e9c86ff533dfbe9d;hb=6ca8a32d88328b8f2162512f41c657c87e131045;hp=cde50e5e7e65a3b732eafadaad539765d363bdf7;hpb=be762d8d9c71a7aa3121e845c45911c7192b7827;p=jalview.git diff --git a/src/jalview/datamodel/SearchResults.java b/src/jalview/datamodel/SearchResults.java index cde50e5..546dd6f 100755 --- a/src/jalview/datamodel/SearchResults.java +++ b/src/jalview/datamodel/SearchResults.java @@ -33,14 +33,15 @@ import java.util.List; */ public class SearchResults implements SearchResultsI { + private int count; - private List matches = new ArrayList<>(); + private ArrayList matches = new ArrayList<>(); /** * One match consists of a sequence reference, start and end positions. * Discontiguous ranges in a sequence require two or more Match objects. */ - public class Match implements SearchResultMatchI + public class Match implements SearchResultMatchI, Comparable { final SequenceI sequence; @@ -91,27 +92,18 @@ public class SearchResults implements SearchResultsI } } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultMatchI#getSequence() - */ @Override public SequenceI getSequence() { return sequence; } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultMatchI#getStart() - */ @Override public int getStart() { return start; } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultMatchI#getEnd() - */ @Override public int getEnd() { @@ -162,30 +154,137 @@ public class SearchResults implements SearchResultsI return (sequence == m.getSequence() && start == m.getStart() && end == m.getEnd()); } + + @Override + public boolean contains(SequenceI seq, int from, int to) + { + return (sequence == seq && start <= from && end >= to); + } + @Override + public boolean adjacent(SequenceI seq, int from, int to) + { + return (sequence == seq && ((start <= from && end >= to) || (from<=(end+1) && to >=(end+1)) || (from<=(start-1) && to>=(start-1)))); + } + + @Override + public int compareTo(SearchResultMatchI o) + { + if (start o.getStart()) + { + return +1; + } + if (end < o.getEnd()) + { + return -1; + } + if (end > o.getEnd()) + { + return +1; + } + if (sequence!=o.getSequence()) + { + int hashc =sequence.hashCode(),oseq=o.getSequence().hashCode(); + return (hashc < oseq) ? -1 : 1; + } + return 0; + } + } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultsI#addResult(jalview.datamodel.SequenceI, int, int) - */ @Override public SearchResultMatchI addResult(SequenceI seq, int start, int end) { Match m = new Match(seq, start, end); - matches.add(m); + if (!matches.contains(m)) + { + matches.add(m); + count++; + } return m; } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultsI#involvesSequence(jalview.datamodel.SequenceI) - */ + @Override + public void addResult(SequenceI seq, int[] positions) + { + /* + * we only increment the match count by 1 - or not at all, + * if the matches are all duplicates of existing + */ + int beforeCount = count; + for (int i = 0; i < positions.length - 1; i += 2) + { + addResult(seq, positions[i], positions[i + 1]); + } + if (count > beforeCount) + { + count = beforeCount + 1; + } + } + + + @Override + public boolean appendResult(SequenceI sequence, int start, int end) + { + + Match m = new Match(sequence, start, end); + + boolean appending=false; + + // we dynamically maintain an interval to add as we test each range in the list + + int cstart=start,cend=end; + List toRemove=new ArrayList<>(); + for (SearchResultMatchI thatm:matches) + { + if (thatm.getSequence()==sequence) + { + if (thatm.contains(sequence,cstart,cend)) + { + // found a match containing the current range. nothing else to do except report if we operated on the list + return appending; + } + if (thatm.adjacent(sequence, cstart, cend)) + { + // update the match to add with the adjacent start/end + start = Math.min(m.start, thatm.getStart()); + end = Math.max(m.end, thatm.getEnd()); + // and check if we keep or remove the old one + if (thatm.getStart()!=start || thatm.getEnd()!=end) + { + toRemove.add(thatm); + count--; + cstart = start; + cend = end; + appending=true; + } else { + return false; + } + } + } + } + matches.removeAll(toRemove); + { + matches.add(new Match(sequence,cstart,cend)); + count++; + } + return appending; + } @Override public boolean involvesSequence(SequenceI sequence) { + final int start = sequence.getStart(); + final int end = sequence.getEnd(); + SequenceI ds = sequence.getDatasetSequence(); - for (SearchResultMatchI _m : matches) + for (SearchResultMatchI m : matches) { - SequenceI matched = _m.getSequence(); - if (matched != null && (matched == sequence || matched == ds)) + SequenceI matched = m.getSequence(); + if (matched != null && (matched == sequence || matched == ds) + && (m.getEnd() >= start) && (m.getStart() <= end)) { return true; } @@ -193,9 +292,6 @@ public class SearchResults implements SearchResultsI return false; } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultsI#getResults(jalview.datamodel.SequenceI, int, int) - */ @Override public int[] getResults(SequenceI sequence, int start, int end) { @@ -219,8 +315,8 @@ public class SearchResults implements SearchResultsI { mfound = true; matchStart = sequence.findIndex(m.start) - 1; - matchEnd = m.start == m.end ? matchStart : sequence - .findIndex(m.end) - 1; + matchEnd = m.start == m.end ? matchStart + : sequence.findIndex(m.end) - 1; } if (mfound) @@ -254,7 +350,7 @@ public class SearchResults implements SearchResultsI else { // debug - // System.err.println("Outwith bounds!" + matchStart+">"+end +" or " + // jalview.bin.Console.errPrintln("Outwith bounds!" + matchStart+">"+end +" or " // + matchEnd+"<"+start); } } @@ -267,9 +363,12 @@ public class SearchResults implements SearchResultsI { int count = 0; BitSet mask = new BitSet(); + int startRes = sqcol.getStartRes(); + int endRes = sqcol.getEndRes(); + for (SequenceI s : sqcol.getSequences()) { - int[] cols = getResults(s, sqcol.getStartRes(), sqcol.getEndRes()); + int[] cols = getResults(s, startRes, endRes); if (cols != null) { for (int pair = 0; pair < cols.length; pair += 2) @@ -287,27 +386,18 @@ public class SearchResults implements SearchResultsI return count; } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultsI#getSize() - */ @Override - public int getSize() + public int getCount() { - return matches.size(); + return count; } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultsI#isEmpty() - */ @Override public boolean isEmpty() { return matches.isEmpty(); } - /* (non-Javadoc) - * @see jalview.datamodel.SearchResultsI#getResults() - */ @Override public List getResults() { @@ -340,8 +430,10 @@ public class SearchResults implements SearchResultsI } /** - * Two SearchResults are considered equal if they contain the same matches in - * the same order. + * Two SearchResults are considered equal if they contain the same matches + * (Sequence, start position, end position) in the same order + * + * @see Match#equals(Object) */ @Override public boolean equals(Object obj) @@ -359,4 +451,28 @@ public class SearchResults implements SearchResultsI { matches.addAll(toAdd.getResults()); } + + @Override + public List getMatchingSubSequences() + { + List seqs = new ArrayList<>(); + + /* + * assemble dataset sequences, and template new sequence features, + * for the amend features dialog + */ + for (SearchResultMatchI match : matches) + { + SequenceI seq = match.getSequence(); + while (seq.getDatasetSequence() != null) + { + seq = seq.getDatasetSequence(); + } + // getSubSequence is index-base0, findIndex returns index-base1 + seqs.add(seq.getSubSequence(seq.findIndex(match.getStart()) - 1, + seq.findIndex(match.getEnd()))); + } + return seqs; + } + }