X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequence.java;h=b50e5af92191c7cd2df24696f40a95db15634d7a;hb=e44876a5a8801c0118b67793ebd57d21079be7b0;hp=6f1b4030d55f897ab5e474515e24b52a003200cd;hpb=cf8e8c6b06fc4272ef915b061ffb12ce555a9bb8;p=jalview.git diff --git a/src/jalview/datamodel/Sequence.java b/src/jalview/datamodel/Sequence.java index 6f1b403..b50e5af 100755 --- a/src/jalview/datamodel/Sequence.java +++ b/src/jalview/datamodel/Sequence.java @@ -22,9 +22,13 @@ package jalview.datamodel; import jalview.analysis.AlignSeq; import jalview.api.DBRefEntryI; +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; @@ -56,8 +60,6 @@ public class Sequence extends ASequence implements SequenceI String vamsasId; - DBRefEntryI sourceDBRef; - DBRefEntry[] dbrefs; RNA rna; @@ -185,12 +187,13 @@ public class Sequence extends ASequence implements SequenceI } /** - * Creates a new Sequence object with new features, DBRefEntries, - * AlignmentAnnotations, and PDBIds but inherits any existing dataset sequence - * reference. + * Creates a new Sequence object with new AlignmentAnnotations but inherits + * any existing dataset sequence reference. If non exists, everything is + * copied. * * @param seq - * DOCUMENT ME! + * if seq is a dataset sequence, behaves like a plain old copy + * constructor */ public Sequence(SequenceI seq) { @@ -213,31 +216,46 @@ public class Sequence extends ASequence implements SequenceI } + /** + * does the heavy lifting when cloning a dataset sequence, or coping data from + * dataset to a new derived sequence. + * + * @param seq + * - source of attributes. + * @param alAnnotation + * - alignment annotation present on seq that should be copied onto + * this sequence + */ protected void initSeqFrom(SequenceI seq, AlignmentAnnotation[] alAnnotation) { - initSeqAndName(seq.getName(), seq.getSequence(), seq.getStart(), + { + char[] oseq = seq.getSequence(); + initSeqAndName(seq.getName(), Arrays.copyOf(oseq, oseq.length), + seq.getStart(), seq.getEnd()); + } description = seq.getDescription(); - sourceDBRef = seq.getSourceDBRef() == null ? null : new DBRefEntry( - seq.getSourceDBRef()); - if (seq.getSequenceFeatures() != null) + if (seq != datasetSequence) { - SequenceFeature[] sf = seq.getSequenceFeatures(); - for (int i = 0; i < sf.length; i++) - { - addSequenceFeature(new SequenceFeature(sf[i])); - } + setDatasetSequence(seq.getDatasetSequence()); } - setDatasetSequence(seq.getDatasetSequence()); if (datasetSequence == null && seq.getDBRefs() != null) { - // only copy DBRefs if we really are a dataset sequence + // only copy DBRefs and seqfeatures if we really are a dataset sequence DBRefEntry[] dbr = seq.getDBRefs(); for (int i = 0; i < dbr.length; i++) { addDBRef(new DBRefEntry(dbr[i])); } + if (seq.getSequenceFeatures() != null) + { + SequenceFeature[] sf = seq.getSequenceFeatures(); + for (int i = 0; i < sf.length; i++) + { + addSequenceFeature(new SequenceFeature(sf[i])); + } + } } if (seq.getAnnotation() != null) { @@ -274,22 +292,36 @@ public class Sequence extends ASequence implements SequenceI } } - /** - * DOCUMENT ME! - * - * @param v - * DOCUMENT ME! - */ + @Override public void setSequenceFeatures(SequenceFeature[] features) { - sequenceFeatures = features; + if (datasetSequence == null) + { + sequenceFeatures = features; + } + else + { + if (datasetSequence.getSequenceFeatures() != features + && datasetSequence.getSequenceFeatures() != null + && datasetSequence.getSequenceFeatures().length > 0) + { + new Exception( + "Warning: JAL-2046 side effect ? Possible implementation error: overwriting dataset sequence features by setting sequence features on alignment") + .printStackTrace(); + } + datasetSequence.setSequenceFeatures(features); + } } @Override public synchronized void addSequenceFeature(SequenceFeature sf) { - // TODO add to dataset sequence instead if there is one? + if (sequenceFeatures==null && datasetSequence != null) + { + datasetSequence.addSequenceFeature(sf); + return; + } if (sequenceFeatures == null) { sequenceFeatures = new SequenceFeature[0]; @@ -315,6 +347,9 @@ public class Sequence extends ASequence implements SequenceI { if (sequenceFeatures == null) { + if (datasetSequence!=null) { + datasetSequence.deleteFeature(sf); + } return; } @@ -936,26 +971,25 @@ public class Sequence extends ASequence implements SequenceI dbrefs = new DBRefEntry[0]; } - int i, iSize = dbrefs.length; - - for (i = 0; i < iSize; i++) + for (DBRefEntryI dbr : dbrefs) { - if (dbrefs[i].equalRef(entry)) + if (dbr.updateFrom(entry)) { - if (entry.getMap() != null) - { - if (dbrefs[i].getMap() == null) - { - // overwrite with 'superior' entry that contains a mapping. - dbrefs[i] = entry; - } - } + /* + * found a dbref that either matched, or could be + * updated from, the new entry - no need to add it + */ return; } } - DBRefEntry[] temp = new DBRefEntry[iSize + 1]; - System.arraycopy(dbrefs, 0, temp, 0, iSize); + /* + * 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; @@ -1037,33 +1071,45 @@ public class Sequence extends ASequence implements SequenceI @Override public SequenceI deriveSequence() { - SequenceI seq = new Sequence(this); - if (datasetSequence != null) - { - // duplicate current sequence with same dataset - seq.setDatasetSequence(datasetSequence); - } - else + Sequence seq=null; + if (datasetSequence == null) { if (isValidDatasetSequence()) { // Use this as dataset sequence + seq = new Sequence(getName(), "", 1, -1); seq.setDatasetSequence(this); + seq.initSeqFrom(this, getAnnotation()); + return seq; } else { // Create a new, valid dataset sequence - SequenceI ds = seq; - ds.setSequence(AlignSeq.extractGaps( - jalview.util.Comparison.GapChars, new String(sequence))); - setDatasetSequence(ds); - ds.setSequenceFeatures(getSequenceFeatures()); - seq = this; // and return this sequence as the derived sequence. + createDatasetSequence(); } } - return seq; + return new Sequence(this); } + private boolean _isNa; + + private long _seqhash = 0; + + @Override + public boolean isProtein() + { + if (datasetSequence != null) + { + return datasetSequence.isProtein(); + } + if (_seqhash != sequence.hashCode()) + { + _seqhash = sequence.hashCode(); + _isNa=jalview.util.Comparison.isNucleotide(new SequenceI[] { this }); + } + return !_isNa; + }; + /* * (non-Javadoc) * @@ -1348,12 +1394,15 @@ public class Sequence extends ASequence implements SequenceI @Override public PDBEntry getPDBEntry(String pdbIdStr) { - if (getDatasetSequence() == null - || getDatasetSequence().getAllPDBEntries() == null) + if (getDatasetSequence() != null) + { + return getDatasetSequence().getPDBEntry(pdbIdStr); + } + if (pdbIds == null) { return null; } - List entries = getDatasetSequence().getAllPDBEntries(); + List entries = getAllPDBEntries(); for (PDBEntry entry : entries) { if (entry.getId().equalsIgnoreCase(pdbIdStr)) @@ -1364,16 +1413,65 @@ public class Sequence extends ASequence implements SequenceI return null; } - @Override - public void setSourceDBRef(DBRefEntryI dbRef) - { - this.sourceDBRef = dbRef; - } @Override - public DBRefEntryI getSourceDBRef() + public List getPrimaryDBRefs() { - return this.sourceDBRef; + if (datasetSequence!=null) + { + return datasetSequence.getPrimaryDBRefs(); + } + if (dbrefs==null || dbrefs.length==0) + { + return Collections.emptyList(); + } + synchronized (dbrefs) + { + List primaries = new ArrayList(); + DBRefEntry[] tmp = new DBRefEntry[1]; + for (DBRefEntry ref : dbrefs) + { + if (!ref.isPrimary()) + { + continue; + } + if (ref.hasMap()) + { + MapList mp = ref.getMap().getMap(); + if (mp.getFromLowest() > start || mp.getFromHighest() < end) + { + // map only involves a subsequence, so cannot be primary + 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()))) + { + // PDB dbrefs imply there should be a PDBEntry associated + // 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); + } + 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; + } + } + return primaries; + } } }