/*
* Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
* Copyright (C) 2014 The Jalview Authors
*
* This file is part of Jalview.
*
* Jalview is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3
* of the License, or (at your option) any later version.
*
* Jalview is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Jalview. If not, see .
* The Jalview Authors are detailed in the 'AUTHORS' file.
*/
package jalview.datamodel;
import java.util.ArrayList;
import java.util.List;
public class SearchResults
{
private List matches = new ArrayList();
/**
* This method replaces the old search results which merely held an alignment
* index of search matches. This broke when sequences were moved around the
* alignment
*
* @param seq
* Sequence
* @param start
* int
* @param end
* int
*/
public void addResult(SequenceI seq, int start, int end)
{
matches.add(new Match(seq, start, end));
}
/**
* Quickly check if the given sequence is referred to in the search results
*
* @param sequence
* (specific alignment sequence or a dataset sequence)
* @return true if the results involve sequence
*/
public boolean involvesSequence(SequenceI sequence)
{
SequenceI ds = sequence.getDatasetSequence();
for (Match m : matches)
{
if (m.sequence != null
&& (m.sequence == sequence || m.sequence == ds))
{
return true;
}
}
return false;
}
/**
* This Method returns the search matches which lie between the start and end
* points of the sequence in question. It is optimised for returning objects
* for drawing on SequenceCanvas
*/
public int[] getResults(SequenceI sequence, int start, int end)
{
if (matches.isEmpty())
{
return null;
}
int[] result = null;
int[] tmp = null;
int resultLength, matchStart = 0, matchEnd = 0;
boolean mfound;
for (Match m : matches)
{
mfound = false;
if (m.sequence == sequence)
{
mfound = true;
// locate aligned position
matchStart = sequence.findIndex(m.start) - 1;
matchEnd = sequence.findIndex(m.end) - 1;
}
else if (m.sequence == sequence.getDatasetSequence())
{
mfound = true;
// locate region in local context
matchStart = sequence.findIndex(m.start) - 1;
matchEnd = sequence.findIndex(m.end) - 1;
}
if (mfound)
{
if (matchStart <= end && matchEnd >= start)
{
if (matchStart < start)
{
matchStart = start;
}
if (matchEnd > end)
{
matchEnd = end;
}
if (result == null)
{
result = new int[]
{ matchStart, matchEnd };
}
else
{
resultLength = result.length;
tmp = new int[resultLength + 2];
System.arraycopy(result, 0, tmp, 0, resultLength);
result = tmp;
result[resultLength] = matchStart;
result[resultLength + 1] = matchEnd;
}
}
else
{
// debug
// System.err.println("Outwith bounds!" + matchStart+">"+end +" or "
// + matchEnd+"<"+start);
}
}
}
return result;
}
public int getSize()
{
return matches.size();
}
public SequenceI getResultSequence(int index)
{
return matches.get(index).sequence;
}
public int getResultStart(int index)
{
return matches.get(index).start;
}
public int getResultEnd(int index)
{
return matches.get(index).end;
}
class Match
{
SequenceI sequence;
int start;
int end;
public Match(SequenceI seq, int start, int end)
{
sequence = seq;
this.start = start;
this.end = end;
}
}
/**
* Returns true if no search result matches are held.
*
* @return
*/
public boolean isEmpty()
{
return matches.isEmpty();
}
}