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 java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
+import com.stevesoft.pat.Regex;
+
import fr.orsay.lri.varna.models.rna.RNA;
/**
*/
public class Sequence extends ASequence implements SequenceI
{
+ private static final Regex limitrx = new Regex(
+ "[/][0-9]{1,}[-][0-9]{1,}$");
+
+ private static final Regex endrx = new Regex("[0-9]{1,}$");
+
SequenceI datasetSequence;
String name;
String vamsasId;
- DBRefEntryI sourceDBRef;
-
DBRefEntry[] dbrefs;
RNA rna;
/** array of sequence features - may not be null for a valid sequence object */
public SequenceFeature[] sequenceFeatures;
+ private SequenceFeatures sequenceFeatureStore;
+
/**
* Creates a new Sequence object.
*
this.sequence = sequence2;
this.start = start2;
this.end = end2;
+ sequenceFeatureStore = new SequenceFeatures();
parseId();
checkValidRange();
}
- com.stevesoft.pat.Regex limitrx = new com.stevesoft.pat.Regex(
- "[/][0-9]{1,}[-][0-9]{1,}$");
-
- com.stevesoft.pat.Regex endrx = new com.stevesoft.pat.Regex("[0-9]{1,}$");
-
void parseId()
{
if (name == null)
protected void initSeqFrom(SequenceI seq,
AlignmentAnnotation[] alAnnotation)
{
- {
- char[] oseq = seq.getSequence();
- initSeqAndName(seq.getName(), Arrays.copyOf(oseq, oseq.length),
- seq.getStart(),
- seq.getEnd());
- }
+ char[] oseq = seq.getSequence();
+ initSeqAndName(seq.getName(), Arrays.copyOf(oseq, oseq.length),
+ seq.getStart(), seq.getEnd());
+
description = seq.getDescription();
if (seq != datasetSequence)
{
setDatasetSequence(seq.getDatasetSequence());
}
- if (datasetSequence == null && seq.getDBRefs() != null)
+
+ /*
+ * only copy DBRefs and seqfeatures if we really are a dataset sequence
+ */
+ if (datasetSequence == null)
{
- // only copy DBRefs and seqfeatures if we really are a dataset sequence
- DBRefEntry[] dbr = seq.getDBRefs();
- for (int i = 0; i < dbr.length; i++)
+ if (seq.getDBRefs() != null)
{
- addDBRef(new DBRefEntry(dbr[i]));
+ DBRefEntry[] dbr = seq.getDBRefs();
+ for (int i = 0; i < dbr.length; i++)
+ {
+ addDBRef(new DBRefEntry(dbr[i]));
+ }
}
if (seq.getSequenceFeatures() != null)
{
}
}
}
+
if (seq.getAnnotation() != null)
{
AlignmentAnnotation[] sqann = seq.getAnnotation();
}
}
-
@Override
public void setSequenceFeatures(SequenceFeature[] features)
{
}
@Override
- public synchronized void addSequenceFeature(SequenceFeature sf)
+ public synchronized boolean addSequenceFeature(SequenceFeature sf)
{
- if (sequenceFeatures==null && datasetSequence != null)
+ if (sf.getType() == null)
{
- datasetSequence.addSequenceFeature(sf);
- return;
+ System.err.println("SequenceFeature type may not be null: "
+ + sf.toString());
+ return false;
+ }
+
+ if (sequenceFeatures == null && datasetSequence != null)
+ {
+ return datasetSequence.addSequenceFeature(sf);
}
if (sequenceFeatures == null)
{
{
if (sequenceFeatures[i].equals(sf))
{
- return;
+ return false;
}
}
temp[sequenceFeatures.length] = sf;
sequenceFeatures = temp;
+
+ sequenceFeatureStore.add(sf);
+ return true;
}
@Override
{
if (sequenceFeatures == null)
{
- if (datasetSequence!=null) {
- datasetSequence.deleteFeature(sf);
+ if (datasetSequence != null)
+ {
+ datasetSequence.deleteFeature(sf);
}
return;
}
+ /*
+ * new way
+ */
+ sequenceFeatureStore.delete(sf);
+
+ /*
+ * old way - to be removed
+ */
int index = 0;
for (index = 0; index < sequenceFeatures.length; index++)
{
}
@Override
- public void addPDBId(PDBEntry entry)
+ public SequenceFeaturesI getFeatures()
+ {
+ return datasetSequence != null ? datasetSequence.getFeatures()
+ : sequenceFeatureStore;
+ }
+
+ @Override
+ public boolean addPDBId(PDBEntry entry)
{
if (pdbIds == null)
{
pdbIds = new Vector<PDBEntry>();
+ pdbIds.add(entry);
+ return true;
}
- if (pdbIds.contains(entry))
- {
- updatePDBEntry(pdbIds.get(pdbIds.indexOf(entry)), entry);
- }
- else
- {
- pdbIds.addElement(entry);
- }
- }
- private static void updatePDBEntry(PDBEntry oldEntry, PDBEntry newEntry)
- {
- if (newEntry.getFile() != null)
+ for (PDBEntry pdbe : pdbIds)
{
- oldEntry.setFile(newEntry.getFile());
+ if (pdbe.updateFrom(entry))
+ {
+ return false;
+ }
}
+ pdbIds.addElement(entry);
+ return true;
}
/**
@Override
public void setDBRefs(DBRefEntry[] dbref)
{
+ if (dbrefs == null && datasetSequence != null
+ && this != datasetSequence)
+ {
+ datasetSequence.setDBRefs(dbref);
+ return;
+ }
dbrefs = dbref;
+ if (dbrefs != null)
+ {
+ DBRefUtils.ensurePrimaries(this);
+ }
}
@Override
@Override
public void addDBRef(DBRefEntry entry)
{
- // TODO add to dataset sequence instead if there is one?
+ if (datasetSequence != null)
+ {
+ datasetSequence.addDBRef(entry);
+ return;
+ }
+
if (dbrefs == null)
{
dbrefs = new DBRefEntry[0];
temp[temp.length - 1] = entry;
dbrefs = temp;
+
+ DBRefUtils.ensurePrimaries(this);
}
@Override
public void setDatasetSequence(SequenceI seq)
{
- // TODO check for circular reference before setting?
+ if (seq == this)
+ {
+ throw new IllegalArgumentException(
+ "Implementation Error: self reference passed to SequenceI.setDatasetSequence");
+ }
+ if (seq != null && seq.getDatasetSequence() != null)
+ {
+ throw new IllegalArgumentException(
+ "Implementation error: cascading dataset sequences are not allowed.");
+ }
datasetSequence = seq;
}
@Override
public SequenceI deriveSequence()
{
- Sequence seq=null;
+ Sequence seq = null;
if (datasetSequence == null)
{
if (isValidDatasetSequence())
else
{
// Create a new, valid dataset sequence
- createDatasetSequence();
+ createDatasetSequence();
}
}
return new Sequence(this);
private long _seqhash = 0;
+ /**
+ * Answers false if the sequence is more than 85% nucleotide (ACGTU), else
+ * true
+ */
@Override
public boolean isProtein()
{
if (_seqhash != sequence.hashCode())
{
_seqhash = sequence.hashCode();
- _isNa=jalview.util.Comparison.isNucleotide(new SequenceI[] { this });
+ _isNa = Comparison.isNucleotide(this);
}
return !_isNa;
};
dsseq.setDescription(description);
// move features and database references onto dataset sequence
dsseq.sequenceFeatures = sequenceFeatures;
- sequenceFeatures=null;
+ sequenceFeatures = null;
+ dsseq.sequenceFeatureStore = sequenceFeatureStore;
+ sequenceFeatureStore = null;
dsseq.dbrefs = dbrefs;
- dbrefs=null;
+ dbrefs = null;
// TODO: search and replace any references to this sequence with
// references to the dataset sequence in Mappings on dbref
dsseq.pdbIds = pdbIds;
return null;
}
- Vector subset = new Vector();
- Enumeration e = annotation.elements();
+ Vector<AlignmentAnnotation> subset = new Vector<AlignmentAnnotation>();
+ Enumeration<AlignmentAnnotation> e = annotation.elements();
while (e.hasMoreElements())
{
- AlignmentAnnotation ann = (AlignmentAnnotation) e.nextElement();
+ AlignmentAnnotation ann = e.nextElement();
if (ann.label != null && ann.label.equals(label))
{
subset.addElement(ann);
e = subset.elements();
while (e.hasMoreElements())
{
- anns[i++] = (AlignmentAnnotation) e.nextElement();
+ anns[i++] = e.nextElement();
}
subset.removeAllElements();
return anns;
{
return false;
}
- Vector newpdb = new Vector();
- for (int i = 0; i < dbrefs.length; i++)
+ boolean added = false;
+ for (DBRefEntry dbr : dbrefs)
{
- if (DBRefSource.PDB.equals(dbrefs[i].getSource()))
+ if (DBRefSource.PDB.equals(dbr.getSource()))
{
- PDBEntry pdbe = new PDBEntry();
- pdbe.setId(dbrefs[i].getAccessionId());
- if (pdbIds == null || pdbIds.size() == 0)
- {
- newpdb.addElement(pdbe);
- }
- else
- {
- Enumeration en = pdbIds.elements();
- boolean matched = false;
- while (!matched && en.hasMoreElements())
- {
- PDBEntry anentry = (PDBEntry) en.nextElement();
- if (anentry.getId().equals(pdbe.getId()))
- {
- matched = true;
- }
- }
- if (!matched)
- {
- newpdb.addElement(pdbe);
- }
- }
- }
- }
- if (newpdb.size() > 0)
- {
- Enumeration en = newpdb.elements();
- while (en.hasMoreElements())
- {
- addPDBId((PDBEntry) en.nextElement());
+ /*
+ * 'Add' any PDB dbrefs as a PDBEntry - add is only performed if the
+ * PDB id is not already present in a 'matching' PDBEntry
+ * Constructor parses out a chain code if appended to the accession id
+ * (a fudge used to 'store' the chain code in the DBRef)
+ */
+ PDBEntry pdbe = new PDBEntry(dbr);
+ added |= addPDBId(pdbe);
}
- return true;
}
- return false;
+ return added;
}
@Override
// transfer PDB entries
if (entry.getAllPDBEntries() != null)
{
- Enumeration e = entry.getAllPDBEntries().elements();
+ Enumeration<PDBEntry> e = entry.getAllPDBEntries().elements();
while (e.hasMoreElements())
{
- PDBEntry pdb = (PDBEntry) e.nextElement();
+ PDBEntry pdb = e.nextElement();
addPDBId(pdb);
}
}
return null;
}
-
@Override
public List<DBRefEntry> getPrimaryDBRefs()
{
- if (datasetSequence!=null)
+ if (datasetSequence != null)
{
return datasetSequence.getPrimaryDBRefs();
}
- if (dbrefs==null || dbrefs.length==0)
+ if (dbrefs == null || dbrefs.length == 0)
{
- return Arrays.asList(new DBRefEntry[0]);
+ return Collections.emptyList();
}
synchronized (dbrefs)
{
List<DBRefEntry> primaries = new ArrayList<DBRefEntry>();
- DBRefEntry tmp[] = new DBRefEntry[1], res[] = null;
+ DBRefEntry[] tmp = new DBRefEntry[1];
for (DBRefEntry ref : dbrefs)
{
- if (!ref.isPrimary())
+ if (!ref.isPrimaryCandidate())
{
continue;
}
DBRefUtils.getCanonicalName(ref.getSource())))
{
// PDB dbrefs imply there should be a PDBEntry associated
- if (getPDBEntry(ref.getAccessionId()) != null)
+ // TODO: tighten PDB dbrefs
+ // formally imply Jalview has actually downloaded and
+ // parsed the pdb file. That means there should be a cached file
+ // 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)
{
primaries.add(ref);
}
}
// check standard protein or dna sources
tmp[0] = ref;
- res = DBRefUtils.selectDbRefs(!isProtein(), tmp);
+ DBRefEntry[] res = DBRefUtils.selectDbRefs(!isProtein(), tmp);
if (res != null && res[0] == tmp[0])
{
primaries.add(ref);
}
}
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public List<SequenceFeature> findFeatures(int from, int to,
+ String... types)
+ {
+ if (datasetSequence != null)
+ {
+ return datasetSequence.findFeatures(from, to, types);
+ }
+ return sequenceFeatureStore.findFeatures(from, to, types);
+ }
}
git://source.jalview.org / jalview.git / blobdiff