X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSearchResults.java;h=546dd6fe229151cb68c55c04e9c86ff533dfbe9d;hb=6ca8a32d88328b8f2162512f41c657c87e131045;hp=8d98fc4590e9939af00a5b75e72cd75f166aa524;hpb=136c0793b90b72b928c4d77dc109dd5c644e00d3;p=jalview.git diff --git a/src/jalview/datamodel/SearchResults.java b/src/jalview/datamodel/SearchResults.java index 8d98fc4..546dd6f 100755 --- a/src/jalview/datamodel/SearchResults.java +++ b/src/jalview/datamodel/SearchResults.java @@ -33,26 +33,27 @@ 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 { - SequenceI sequence; + final SequenceI sequence; /** * Start position of match in sequence (base 1) */ - int start; + final int start; /** * End position (inclusive) (base 1) */ - int end; + final int end; /** * create a Match on a range of sequence. Match always holds region in @@ -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() { @@ -133,11 +125,6 @@ public class SearchResults implements SearchResultsI return sb.toString(); } - public void setSequence(SequenceI seq) - { - this.sequence = seq; - } - /** * Hashcode is the hashcode of the matched sequence plus a hash of start and * end positions. Match objects that pass the test for equals are guaranteed @@ -164,33 +151,140 @@ public class SearchResults implements SearchResultsI return false; } SearchResultMatchI m = (SearchResultMatchI) obj; - return (sequence == m.getSequence() && start == m.getStart() && end == m - .getEnd()); + 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; } @@ -198,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) { @@ -224,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) @@ -259,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); } } @@ -272,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) @@ -292,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() { @@ -345,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) @@ -358,4 +445,34 @@ public class SearchResults implements SearchResultsI SearchResultsI sr = (SearchResultsI) obj; return matches.equals(sr.getResults()); } + + @Override + public void addSearchResults(SearchResultsI toAdd) + { + 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; + } + }