package jalview.datamodel;
import jalview.analysis.AlignSeq;
-import jalview.api.DBRefEntryI;
import jalview.datamodel.features.SequenceFeatures;
import jalview.datamodel.features.SequenceFeaturesI;
import jalview.util.Comparison;
import jalview.util.DBRefUtils;
import jalview.util.MapList;
import jalview.util.StringUtils;
+import jalview.ws.params.InvalidArgumentException;
import java.util.ArrayList;
import java.util.Arrays;
*/
public class Sequence extends ASequence implements SequenceI
{
- SequenceI datasetSequence;
+
+ /**
+ * A subclass that gives us access to modCount, which tracks
+ * whether there have been any changes. We use this to update
+ * @author hansonr
+ *
+ * @param <T>
+ */
+ @SuppressWarnings("serial")
+ protected class DBModList<T> extends ArrayList<DBRefEntry> {
+
+ protected int getModCount() {
+ return modCount;
+ }
+
+ }
+
+SequenceI datasetSequence;
String name;
String vamsasId;
- DBRefEntry[] dbrefs;
+ private DBModList<DBRefEntry> dbrefs; // controlled acces
- RNA rna;
+ /**
+ * a flag to let us know that elements have changed in dbrefs
+ *
+ * @author Bob Hanson
+ */
+ private int refModCount = 0;
+ RNA rna;
+
/**
* This annotation is displayed below the alignment but the positions are tied
* to the residues of this sequence
*/
if (datasetSequence == null)
{
- if (seq.getDBRefs() != null)
+ List<DBRefEntry> dbr = seq.getDBRefs();
+ if (dbr != null)
{
- DBRefEntry[] dbr = seq.getDBRefs();
- for (int i = 0; i < dbr.length; i++)
+ for (int i = 0, n = dbr.size(); i < n; i++)
{
- addDBRef(new DBRefEntry(dbr[i]));
+ addDBRef(new DBRefEntry(dbr.get(i)));
}
}
@Override
public GeneLociI getGeneLoci()
{
- DBRefEntry[] refs = getDBRefs();
+ List<DBRefEntry> refs = getDBRefs();
if (refs != null)
{
for (final DBRefEntry ref : refs)
vamsasId = id;
}
- @Override
- public void setDBRefs(DBRefEntry[] dbref)
+ @SuppressWarnings("deprecation")
+@Override
+ public void setDBRefs(List<DBRefEntry> newDBrefs) throws InvalidArgumentException
{
if (dbrefs == null && datasetSequence != null
&& this != datasetSequence)
{
- datasetSequence.setDBRefs(dbref);
+ datasetSequence.setDBRefs((DBModList<DBRefEntry>)newDBrefs);
return;
}
- dbrefs = dbref;
- if (dbrefs != null)
- {
- DBRefUtils.ensurePrimaries(this);
- }
+ if (newDBrefs != null && !(newDBrefs instanceof DBModList<?>))
+ throw new InvalidArgumentException("DBrefs must have DBModList class");
+
+ dbrefs = (DBModList<DBRefEntry>)newDBrefs;
+ refModCount = 0;
+ }
+
+ @Override
+ public void getDBRefsFrom(SequenceI seq) {
+ try {
+ setDBRefs(seq.getDBRefs());
+ } catch (InvalidArgumentException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
}
@Override
- public DBRefEntry[] getDBRefs()
+ public List<DBRefEntry> getDBRefs()
{
if (dbrefs == null && datasetSequence != null
&& this != datasetSequence)
return dbrefs;
}
+
@Override
public void addDBRef(DBRefEntry entry)
{
if (dbrefs == null)
{
- dbrefs = new DBRefEntry[0];
+ dbrefs = new DBModList<DBRefEntry>();
}
- for (DBRefEntryI dbr : dbrefs)
+ for (int ib = 0, nb= dbrefs.size(); ib < nb; ib++)
{
- if (dbr.updateFrom(entry))
+ if (dbrefs.get(ib).updateFrom(entry))
{
/*
* found a dbref that either matched, or could be
}
}
- /*
- * extend the array to make room for one more
- */
- // TODO use an ArrayList instead
- int j = dbrefs.length;
- DBRefEntry[] temp = new DBRefEntry[j + 1];
- System.arraycopy(dbrefs, 0, temp, 0, j);
- temp[temp.length - 1] = entry;
-
- dbrefs = temp;
- DBRefUtils.ensurePrimaries(this);
+// /// BH OUCH!
+// /*
+// * extend the array to make room for one more
+// */
+// // TODO use an ArrayList instead
+// int j = dbrefs.length;
+// List<DBRefEntry> temp = new DBRefEntry[j + 1];
+// System.arraycopy(dbrefs, 0, temp, 0, j);
+// temp[temp.length - 1] = entry;
+//
+// dbrefs = temp;
+
+ dbrefs.add(entry);
}
@Override
private int _seqhash = 0;
+private List<DBRefEntry> primaryRefs;
+
/**
* Answers false if the sequence is more than 85% nucleotide (ACGTU), else
* true
// TODO: could merge DBRefs
return datasetSequence.updatePDBIds();
}
- if (dbrefs == null || dbrefs.length == 0)
+ if (dbrefs == null || dbrefs.size() == 0)
{
return false;
}
boolean added = false;
- for (DBRefEntry dbr : dbrefs)
+ for (int ib = 0, nb = dbrefs.size(); ib < nb; ib++)
{
+ DBRefEntry dbr = dbrefs.get(ib);
if (DBRefSource.PDB.equals(dbr.getSource()))
{
/*
}
}
// transfer database references
- DBRefEntry[] entryRefs = entry.getDBRefs();
+ List<DBRefEntry> entryRefs = entry.getDBRefs();
if (entryRefs != null)
{
- for (int r = 0; r < entryRefs.length; r++)
+ for (int r = 0, n = entryRefs.size(); r < n; r++)
{
- DBRefEntry newref = new DBRefEntry(entryRefs[r]);
+ DBRefEntry newref = new DBRefEntry(entryRefs.get(r));
if (newref.getMap() != null && mp != null)
{
// remap ref using our local mapping
return null;
}
+ private List<DBRefEntry> tmpList;
+
@Override
public List<DBRefEntry> getPrimaryDBRefs()
{
{
return datasetSequence.getPrimaryDBRefs();
}
- if (dbrefs == null || dbrefs.length == 0)
+ if (dbrefs == null || dbrefs.size() == 0)
{
return Collections.emptyList();
}
synchronized (dbrefs)
{
- List<DBRefEntry> primaries = new ArrayList<>();
- DBRefEntry[] tmp = new DBRefEntry[1];
- for (DBRefEntry ref : dbrefs)
+ if (refModCount == dbrefs.getModCount() && primaryRefs != null)
+ return primaryRefs;
{
+ refModCount = dbrefs.getModCount();
+ DBRefUtils.ensurePrimaries(this);
+ primaryRefs = null;
+ }
+ List<DBRefEntry> primaries = (primaryRefs == null ? (primaryRefs = new ArrayList<>()) : primaryRefs);
+ primaries.clear();
+ if (tmpList == null) {
+ tmpList = new ArrayList<>();
+ tmpList.add(null); // for replacement
+ }
+ for (int i = 0, n = dbrefs.size(); i < n; i++)
+ {
+ DBRefEntry ref = dbrefs.get(i);
if (!ref.isPrimaryCandidate())
{
continue;
}
}
// whilst it looks like it is a primary ref, we also sanity check type
- if (DBRefUtils.getCanonicalName(DBRefSource.PDB)
- .equals(DBRefUtils.getCanonicalName(ref.getSource())))
+ if (DBRefSource.PDB_CANONICAL_NAME.equals(ref.getCanonicalSourceName()))
{
// PDB dbrefs imply there should be a PDBEntry associated
// TODO: tighten PDB dbrefs
// handle on the PDBEntry, and a real mapping between sequence and
// extracted sequence from PDB file
PDBEntry pdbentry = getPDBEntry(ref.getAccessionId());
- if (pdbentry != null && pdbentry.getFile() != null)
+ if (pdbentry == null || pdbentry.getFile() == null)
{
- primaries.add(ref);
+ continue;
}
- continue;
- }
- // check standard protein or dna sources
- tmp[0] = ref;
- DBRefEntry[] res = DBRefUtils.selectDbRefs(!isProtein(), tmp);
- if (res != null && res[0] == tmp[0])
- {
- primaries.add(ref);
- continue;
- }
+ } else {
+ // check standard protein or dna sources
+ tmpList.set(0, ref);
+ List<DBRefEntry> res = DBRefUtils.selectDbRefs(!isProtein(), tmpList);
+ if (res == null || res.get(0) != tmpList.get(0))
+ {
+ continue;
+ }
+ }
+ primaries.add(ref);
}
return primaries;
}