}
// NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work
- for (int i = 0; i < len; i++)
+ List<SequenceI> asq;
+ synchronized (asq = align.getSequences())
{
- // SequenceI tmp = seqs[i];
- align.getSequences().setElementAt(seqs[nSeq - i - 1], i);
- align.getSequences().setElementAt(seqs[i], nSeq - i - 1);
+ for (int i = 0; i < len; i++)
+ {
+ // SequenceI tmp = seqs[i];
+ asq.set(i, seqs[nSeq - i - 1]);
+ asq.set(nSeq - i - 1, seqs[i]);
+ }
}
}
public static void setOrder(AlignmentI align, SequenceI[] seqs)
{
// NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work
- Vector algn = align.getSequences();
- Vector tmp = new Vector();
-
- for (int i = 0; i < seqs.length; i++)
+ List<SequenceI> algn;
+ synchronized (algn = align.getSequences())
{
- if (algn.contains(seqs[i]))
+ List<SequenceI> tmp = new ArrayList<SequenceI>();
+
+ for (int i = 0; i < seqs.length; i++)
{
- tmp.addElement(seqs[i]);
+ if (algn.contains(seqs[i]))
+ {
+ tmp.add(seqs[i]);
+ }
}
- }
- algn.removeAllElements();
- // User may have hidden seqs, then clicked undo or redo
- for (int i = 0; i < tmp.size(); i++)
- {
- algn.addElement(tmp.elementAt(i));
+ algn.clear();
+ // User may have hidden seqs, then clicked undo or redo
+ for (int i = 0; i < tmp.size(); i++)
+ {
+ algn.add(tmp.get(i));
+ }
}
-
}
/**
}
/**
- * DOCUMENT ME!
- *
+ * Select sequences in order from tmp that is present in mask, and any
+ * remaining seqeunces in mask not in tmp
+ *
* @param tmp
- * DOCUMENT ME!
+ * thread safe collection of sequences
* @param mask
- * DOCUMENT ME!
- *
- * @return DOCUMENT ME!
+ * thread safe collection of sequences
+ *
+ * @return intersect(tmp,mask)+intersect(complement(tmp),mask)
*/
- private static SequenceI[] vectorSubsetToArray(Vector tmp, Vector mask)
+ private static SequenceI[] vectorSubsetToArray(List<SequenceI> tmp,
+ List<SequenceI> mask)
{
- Vector seqs = new Vector();
+ ArrayList<SequenceI> seqs = new ArrayList<SequenceI>();
int i, idx;
boolean[] tmask = new boolean[mask.size()];
for (i = 0; i < tmp.size(); i++)
{
- Object sq = tmp.elementAt(i);
+ SequenceI sq = tmp.get(i);
idx = mask.indexOf(sq);
if (idx > -1 && tmask[idx])
{
tmask[idx] = false;
- seqs.addElement(sq);
+ seqs.add(sq);
}
}
{
if (tmask[i])
{
- seqs.addElement(mask.elementAt(i));
+ seqs.add(mask.get(i));
}
}
- return vectorToArray(seqs);
+ return seqs.toArray(new SequenceI[seqs.size()]);
}
/**
* @return DOCUMENT ME!
*/
private static Vector _sortByTree(SequenceNode node, Vector tmp,
- Vector seqset)
+ List<SequenceI> seqset)
{
if (node == null)
{
package jalview.analysis;\r
\r
import java.util.Enumeration;\r
+import java.util.List;\r
import java.util.Vector;\r
import java.util.Hashtable;\r
\r
System.err.println("Empty dataset sequence set - NO VECTOR");\r
return false;\r
}\r
- Enumeration e = dataset.getSequences().elements();\r
- while (e.hasMoreElements())\r
+ List<SequenceI> ds;\r
+ synchronized (ds=dataset.getSequences())\r
{\r
- SequenceI nxt = (SequenceI) e.nextElement();\r
+ for (SequenceI nxt:ds)\r
if (nxt != null)\r
{\r
if (nxt.getDatasetSequence() != null)\r
import jalview.datamodel.ColumnSelection;\r
import jalview.datamodel.PDBEntry;\r
import jalview.datamodel.Sequence;\r
+import jalview.datamodel.SequenceCollectionI;\r
import jalview.datamodel.SequenceGroup;\r
import jalview.datamodel.SequenceI;\r
import jalview.io.AnnotationFile;\r
package jalview.appletgui;
import java.util.*;
+import java.util.List;
import java.awt.*;
{
if (i < comp.getHeight())
{
- comp.getSequences().insertElementAt(a1[i], i);
+ // TODO: the following does not trigger any recalculation of height/etc, or maintain the dataset
+ List<SequenceI> alsq;
+ synchronized (alsq=comp.getSequences()) {
+ alsq.add(i, a1[i]);
+ }
}
else
{
// read it to the alignment
if (command.alIndex[i] < command.al.getHeight())
{
- command.al.getSequences().insertElementAt(command.seqs[i],
- command.alIndex[i]);
+ List<SequenceI> sequences;
+ synchronized (sequences=command.al.getSequences()) {
+ sequences.add(command.alIndex[i], command.seqs[i]);
+ }
}
else
{
{
protected Alignment dataset;
- protected Vector sequences;
+ protected List<SequenceI> sequences;
- protected Vector groups = new Vector();
+ protected List<SequenceGroup> groups = java.util.Collections
+ .synchronizedList(new ArrayList<SequenceGroup>());
protected char gapCharacter = '-';
type = PROTEIN;
}
- sequences = new Vector();
+ sequences = java.util.Collections
+ .synchronizedList(new ArrayList<SequenceI>());
for (i = 0; i < seqs.length; i++)
{
- sequences.addElement(seqs[i]);
+ sequences.add(seqs[i]);
}
}
*
* @return DOCUMENT ME!
*/
- public Vector getSequences()
+ @Override
+ public List<SequenceI> getSequences()
{
return sequences;
}
{
if (sequences == null)
return null;
- SequenceI[] reply = new SequenceI[sequences.size()];
- for (int i = 0; i < sequences.size(); i++)
+ synchronized (sequences)
{
- reply[i] = (SequenceI) sequences.elementAt(i);
+ return sequences.toArray(new SequenceI[sequences.size()]);
}
- return reply;
}
/**
*/
public SequenceI getSequenceAt(int i)
{
- if (i>-1 && i < sequences.size())
+ synchronized (sequences)
{
- return (SequenceI) sequences.elementAt(i);
+ if (i > -1 && i < sequences.size())
+ {
+ return sequences.get(i);
+ }
}
-
return null;
}
}
else
{
- sequences.addElement(snew);
+ synchronized (sequences)
+ {
+ sequences.add(snew);
+ }
}
if (hiddenSequences != null)
hiddenSequences.adjustHeightSequenceAdded();
public void setSequenceAt(int i, SequenceI snew)
{
SequenceI oldseq = getSequenceAt(i);
- deleteSequence(oldseq);
-
- sequences.setElementAt(snew, i);
+ deleteSequence(i);
+ synchronized (sequences)
+ {
+ sequences.set(i, snew);
+ }
}
/**
{
if (i > -1 && i < getHeight())
{
- sequences.removeElementAt(i);
+ synchronized (sequences)
+ {
+ sequences.remove(i);
+ }
hiddenSequences.adjustHeightSequenceDeleted(i);
}
}
- /** */
+ /*
+ * (non-Javadoc)
+ *
+ * @see jalview.datamodel.AlignmentI#findGroup(jalview.datamodel.SequenceI)
+ */
+ @Override
public SequenceGroup findGroup(SequenceI s)
{
- for (int i = 0; i < this.groups.size(); i++)
+ synchronized (groups)
{
- SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
-
- if (sg.getSequences(null).contains(s))
+ for (int i = 0; i < this.groups.size(); i++)
{
- return sg;
+ SequenceGroup sg = groups.get(i);
+
+ if (sg.getSequences(null).contains(s))
+ {
+ return sg;
+ }
}
}
-
return null;
}
*/
public SequenceGroup[] findAllGroups(SequenceI s)
{
- Vector temp = new Vector();
+ ArrayList<SequenceGroup> temp = new ArrayList<SequenceGroup>();
- int gSize = groups.size();
- for (int i = 0; i < gSize; i++)
+ synchronized (groups)
{
- SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
- if (sg == null || sg.getSequences(null) == null)
+ int gSize = groups.size();
+ for (int i = 0; i < gSize; i++)
{
- this.deleteGroup(sg);
- gSize--;
- continue;
- }
+ SequenceGroup sg = groups.get(i);
+ if (sg == null || sg.getSequences(null) == null)
+ {
+ this.deleteGroup(sg);
+ gSize--;
+ continue;
+ }
- if (sg.getSequences(null).contains(s))
- {
- temp.addElement(sg);
+ if (sg.getSequences(null).contains(s))
+ {
+ temp.add(sg);
+ }
}
}
-
SequenceGroup[] ret = new SequenceGroup[temp.size()];
-
- for (int i = 0; i < temp.size(); i++)
- {
- ret[i] = (SequenceGroup) temp.elementAt(i);
- }
-
- return ret;
+ return temp.toArray(ret);
}
/** */
public void addGroup(SequenceGroup sg)
{
- if (!groups.contains(sg))
+ synchronized (groups)
{
- if (hiddenSequences.getSize() > 0)
+ if (!groups.contains(sg))
{
- int i, iSize = sg.getSize();
- for (i = 0; i < iSize; i++)
+ if (hiddenSequences.getSize() > 0)
{
- if (!sequences.contains(sg.getSequenceAt(i)))
+ int i, iSize = sg.getSize();
+ for (i = 0; i < iSize; i++)
{
- sg.deleteSequence(sg.getSequenceAt(i), false);
- iSize--;
- i--;
+ if (!sequences.contains(sg.getSequenceAt(i)))
+ {
+ sg.deleteSequence(sg.getSequenceAt(i), false);
+ iSize--;
+ i--;
+ }
}
- }
- if (sg.getSize() < 1)
- {
- return;
+ if (sg.getSize() < 1)
+ {
+ return;
+ }
}
- }
- groups.addElement(sg);
+ groups.add(sg);
+ }
}
}
public void deleteAllGroups()
{
- if (annotations != null)
+ synchronized (groups)
{
- removeAnnotationForGroup(null);
+ if (annotations != null)
+ {
+ removeAnnotationForGroup(null);
+ }
+ groups.clear();
}
- groups.removeAllElements();
}
/** */
public void deleteGroup(SequenceGroup g)
{
- if (groups.contains(g))
+ synchronized (groups)
{
- removeAnnotationForGroup(g);
- groups.removeElement(g);
+ if (groups.contains(g))
+ {
+ removeAnnotationForGroup(g);
+ groups.remove(g);
+ }
}
}
public void setGapCharacter(char gc)
{
gapCharacter = gc;
-
- for (int i = 0; i < sequences.size(); i++)
+ synchronized (sequences)
{
- Sequence seq = (Sequence) sequences.elementAt(i);
- seq.setSequence(seq.getSequenceAsString().replace('.', gc)
- .replace('-', gc).replace(' ', gc));
+ for (SequenceI seq : sequences)
+ {
+ seq.setSequence(seq.getSequenceAsString().replace('.', gc)
+ .replace('-', gc).replace(' ', gc));
+ }
}
}
public CigarArray getCompactAlignment()
{
- SeqCigar alseqs[] = new SeqCigar[sequences.size()];
- for (int i = 0; i < sequences.size(); i++)
+ synchronized (sequences)
{
- alseqs[i] = new SeqCigar((SequenceI) sequences.elementAt(i));
+ SeqCigar alseqs[] = new SeqCigar[sequences.size()];
+ int i = 0;
+ for (SequenceI seq : sequences)
+ {
+ alseqs[i++] = new SeqCigar(seq);
+ }
+ CigarArray cal = new CigarArray(alseqs);
+ cal.addOperation(CigarArray.M, getWidth());
+ return cal;
}
- CigarArray cal = new CigarArray(alseqs);
- cal.addOperation(CigarArray.M, getWidth());
- return cal;
}
+ @Override
public void setProperty(Object key, Object value)
{
if (alignmentProperties == null)
public void append(AlignmentI toappend)
{
+ if (toappend == this)
+ {
+ System.err.println("Self append may cause a deadlock.");
+ }
// TODO test this method for a future 2.5 release
// currently tested for use in jalview.gui.SequenceFetcher
boolean samegap = toappend.getGapCharacter() == getGapCharacter();
boolean hashidden = toappend.getHiddenSequences() != null
&& toappend.getHiddenSequences().hiddenSequences != null;
// get all sequences including any hidden ones
- Vector sqs = (hashidden) ? toappend.getHiddenSequences()
+ List<SequenceI> sqs = (hashidden) ? toappend.getHiddenSequences()
.getFullAlignment().getSequences() : toappend.getSequences();
if (sqs != null)
{
- Enumeration sq = sqs.elements();
- while (sq.hasMoreElements())
+ synchronized (sqs)
{
- SequenceI addedsq = (SequenceI) sq.nextElement();
- if (!samegap)
+ for (SequenceI addedsq : sqs)
{
- char[] oldseq = addedsq.getSequence();
- for (int c = 0; c < oldseq.length; c++)
+ if (!samegap)
{
- if (oldseq[c] == oldc)
+ char[] oldseq = addedsq.getSequence();
+ for (int c = 0; c < oldseq.length; c++)
{
- oldseq[c] = gapCharacter;
+ if (oldseq[c] == oldc)
+ {
+ oldseq[c] = gapCharacter;
+ }
}
}
+ addSequence(addedsq);
}
- addSequence(addedsq);
}
}
AlignmentAnnotation[] alan = toappend.getAlignmentAnnotation();
public boolean isAligned(boolean includeHidden);
/**
- * Gets sequences as a Vector
- *
+ * Gets sequences as a Synchronized collection
+ *
* @return All sequences in alignment.
*/
- public Vector getSequences();
+ @Override
+ public List<SequenceI> getSequences();
/**
* Gets sequences as a SequenceI[]
end = hiddenSequences.length - 1;
}
- for (int index = end; index > start; index--)
+ List<SequenceI> asequences;
+ synchronized (asequences = alignment.getSequences())
{
- SequenceI seq = hiddenSequences[index];
- hiddenSequences[index] = null;
-
- if (seq != null)
+ for (int index = end; index > start; index--)
{
- if (seq.getLength() > 0)
- {
- revealedSeqs.addElement(seq);
- alignment.getSequences().insertElementAt(seq, alignmentIndex);
- }
- else
+ SequenceI seq = hiddenSequences[index];
+ hiddenSequences[index] = null;
+
+ if (seq != null)
{
- System.out.println(seq.getName()
- + " has been deleted whilst hidden");
+ if (seq.getLength() > 0)
+ {
+ revealedSeqs.addElement(seq);
+ asequences.add(alignmentIndex, seq);
+ }
+ else
+ {
+ System.out.println(seq.getName()
+ + " has been deleted whilst hidden");
+ }
}
- }
+ }
}
return revealedSeqs;
// almost certainly a quicker way to do this - but we keep it simple
Hashtable scoreSorts = new Hashtable();
AlignmentAnnotation aann[];
- Enumeration sq = viewport.getAlignment().getSequences().elements();
- while (sq.hasMoreElements())
+ for (SequenceI sqa:viewport.getAlignment().getSequences())
{
- aann = ((SequenceI) sq.nextElement()).getAnnotation();
+ aann = sqa.getAnnotation();
for (int i = 0; aann != null && i < aann.length; i++)
{
if (aann[i].hasScore() && aann[i].sequenceRef != null)
package jalview.gui;
import java.util.*;
+import java.util.List;
import java.awt.*;
{
if (i < comp.getHeight())
{
- comp.getSequences().insertElementAt(a1[i], i);
+ // TODO: the following does not trigger any recalculation of height/etc, or maintain the dataset
+ if (comp.getDataset()!=source.getDataset())
+ {
+ // raise an implementation warning here - not sure if this situation will ever occur
+ System.err.println("IMPLEMENTATION PROBLEM: DATASET out of sync due to an insert whilst calling PaintRefresher.validateSequences(AlignmentI, ALignmentI)");
+ }
+ List<SequenceI> alsq;
+ synchronized (alsq=comp.getSequences()) {
+ alsq.add(i, a1[i]);
+ }
}
else
{
title = getDefaultRetrievalTitle();
}
SequenceFeature[] sfs = null;
- for (Enumeration sq = al.getSequences().elements(); sq
- .hasMoreElements();)
+ List<SequenceI> alsqs;
+ synchronized (alsqs = al.getSequences())
{
- if ((sfs = ((SequenceI) sq.nextElement()).getDatasetSequence()
- .getSequenceFeatures()) != null)
+ for (SequenceI sq : alsqs)
{
- if (sfs.length > 0)
+ if ((sfs = (sq).getDatasetSequence().getSequenceFeatures()) != null)
{
- af.setShowSeqFeatures(true);
- break;
+ if (sfs.length > 0)
+ {
+ af.setShowSeqFeatures(true);
+ break;
+ }
}
- }
+ }
}
Desktop.addInternalFrame(af, title, AlignFrame.DEFAULT_WIDTH,
AlignFrame.DEFAULT_HEIGHT);
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.Iterator;
+import java.util.List;
import java.util.Vector;
import java.util.jar.JarInputStream;
import java.util.jar.JarOutputStream;
else
{
// first find the alignment sequence to associate this with.
- SequenceI jvalsq = null;
- Enumeration jval = av.getAlignment().getSequences()
- .elements();
- while (jval.hasMoreElements())
- {
- jvalsq = (SequenceI) jval.nextElement();
+ for (SequenceI jvalsq:av.getAlignment().getSequences()) {
// saveDatasetSequenceAnnotation(AlSeqMaps,(uk.ac.vamsas.objects.core.Sequence)
// sref, aa[i]);
if (jvalsq.getDatasetSequence() == aa[i].sequenceRef)
* creates/syncs the jvalsq from the alignment sequence
*/
private boolean syncFromAlignmentSequence(AlignmentSequence valseq,
- char valGapchar, char gapChar, Vector dsseqs)
+ char valGapchar, char gapChar, List<SequenceI> dsseqs)
{
boolean modal = false;
// ///LOAD DATASET
DataSet dataset = root.getDataSet(_ds);
int i, iSize = dataset.getSequenceCount();
- Vector dsseqs;
+ List<SequenceI> dsseqs;
jalview.datamodel.Alignment jdataset = (jalview.datamodel.Alignment) getvObj2jv(dataset);
int jremain = 0;
if (jdataset == null)
SequenceI[] seqs = new SequenceI[dsseqs.size()];
for (i = 0, iSize = dsseqs.size(); i < iSize; i++)
{
- seqs[i] = (SequenceI) dsseqs.elementAt(i);
- dsseqs.setElementAt(null, i);
+ seqs[i] = dsseqs.get(i);
+ dsseqs.set(i, null);
}
jdataset = new jalview.datamodel.Alignment(seqs);
Cache.log.debug("New vamsas dataset imported into jalview.");
SequenceI[] seqs = new SequenceI[dsseqs.size()];
for (i = 0, iSize = dsseqs.size(); i < iSize; i++)
{
- seqs[i] = (SequenceI) dsseqs.elementAt(i);
- dsseqs.setElementAt(null, i);
+ seqs[i] = dsseqs.get(i);
+ dsseqs.set(i,null);
}
jal = new jalview.datamodel.Alignment(seqs);
Cache.log.debug("New vamsas alignment imported into jalview "
import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;
+import java.util.List;
import java.util.Vector;
import jalview.analysis.NJTree;
SeqCigar[] tseqs = new SeqCigar[sequences.length];
System.arraycopy(sequences, 0, tseqs, 0, sequences.length);
Vector alsq = new Vector();
- Enumeration as = jal.getSequences().elements();
- while (as.hasMoreElements())
+ List<SequenceI> jalsqs;
+ synchronized (jalsqs=jal.getSequences())
+ {for (SequenceI asq:jalsqs)
{
- SequenceI asq = (SequenceI) as.nextElement();
for (int t = 0; t < sequences.length; t++)
{
if (tseqs[t] != null