X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequence.java;h=5bb55e5de37c04b90c103f64cc2f0315f2e852fa;hb=cd886ae669962ea7fff5fb46627b3f84e77d295d;hp=6f5c18a6ce06b4512bd6294f034000487fe81813;hpb=cbeb7ad59d51b468c54ca3db2a2a7693060a2509;p=jalview.git

diff --git a/src/jalview/datamodel/Sequence.java b/src/jalview/datamodel/Sequence.java
index 6f5c18a..5bb55e5 100755
--- a/src/jalview/datamodel/Sequence.java
+++ b/src/jalview/datamodel/Sequence.java
@@ -20,18 +20,10 @@
  */
 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 java.util.ArrayList;
 import java.util.Arrays;
 import java.util.BitSet;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.Iterator;
@@ -40,6 +32,16 @@ import java.util.ListIterator;
 import java.util.Vector;
 
 import fr.orsay.lri.varna.models.rna.RNA;
+import jalview.analysis.AlignSeq;
+import jalview.analysis.AlignmentUtils;
+import jalview.analysis.SeqsetUtils;
+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.datamodel.alphafold.MappableContactMatrix;
 
 /**
  * 
@@ -47,25 +49,52 @@ import fr.orsay.lri.varna.models.rna.RNA;
  */
 public class Sequence extends ASequence implements SequenceI
 {
+
+  /**
+   * 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")
+  public class DBModList<T> extends ArrayList<DBRefEntry>
+  {
+
+    protected int getModCount()
+    {
+      return modCount;
+    }
+
+  }
+
   SequenceI datasetSequence;
 
-  String name;
+  private String name;
 
   private char[] sequence;
 
-  String description;
+  private String description;
+
+  private int start;
 
-  int start;
+  private int end;
 
-  int end;
+  private Vector<PDBEntry> pdbIds;
 
-  Vector<PDBEntry> pdbIds;
+  private String vamsasId;
 
-  String vamsasId;
+  private DBModList<DBRefEntry> dbrefs; // controlled access
 
-  DBRefEntry[] dbrefs;
+  /**
+   * a flag to let us know that elements have changed in dbrefs
+   * 
+   * @author Bob Hanson
+   */
+  private int refModCount = 0;
 
-  RNA rna;
+  private RNA rna;
 
   /**
    * This annotation is displayed below the alignment but the positions are tied
@@ -73,7 +102,7 @@ public class Sequence extends ASequence implements SequenceI
    *
    * TODO: change to List<>
    */
-  Vector<AlignmentAnnotation> annotation;
+  private Vector<AlignmentAnnotation> annotation;
 
   private SequenceFeaturesI sequenceFeatureStore;
 
@@ -278,18 +307,18 @@ public class Sequence extends ASequence implements SequenceI
     {
       setDatasetSequence(seq.getDatasetSequence());
     }
-    
+
     /*
      * only copy DBRefs and seqfeatures if we really are a dataset 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)));
         }
       }
 
@@ -323,6 +352,11 @@ public class Sequence extends ASequence implements SequenceI
         {
           // only copy the given annotation
           AlignmentAnnotation newann = new AlignmentAnnotation(sqann[i]);
+          ContactMatrixI cm = seq.getContactMatrixFor(sqann[i]);
+          if (cm!=null)
+          {
+            addContactListFor(newann, cm);
+          }
           addAlignmentAnnotation(newann);
         }
       }
@@ -353,8 +387,8 @@ public class Sequence extends ASequence implements SequenceI
   {
     if (sf.getType() == null)
     {
-      System.err.println("SequenceFeature type may not be null: "
-              + sf.toString());
+      System.err.println(
+              "SequenceFeature type may not be null: " + sf.toString());
       return false;
     }
 
@@ -446,18 +480,19 @@ public class Sequence extends ASequence implements SequenceI
   }
 
   /**
-   * DOCUMENT ME!
+   * Answers the sequence name, with '/start-end' appended if jvsuffix is true
    * 
-   * @return DOCUMENT ME!
+   * @return
    */
   @Override
   public String getDisplayId(boolean jvsuffix)
   {
-    StringBuffer result = new StringBuffer(name);
-    if (jvsuffix)
+    if (!jvsuffix)
     {
-      result.append("/" + start + "-" + end);
+      return name;
     }
+    StringBuilder result = new StringBuilder(name);
+    result.append("/").append(start).append("-").append(end);
 
     return result.toString();
   }
@@ -496,6 +531,7 @@ public class Sequence extends ASequence implements SequenceI
   public void setStart(int start)
   {
     this.start = start;
+    sequenceChanged();
   }
 
   /**
@@ -573,8 +609,8 @@ public class Sequence extends ASequence implements SequenceI
   public char[] getSequence()
   {
     // return sequence;
-    return sequence == null ? null : Arrays.copyOf(sequence,
-            sequence.length);
+    return sequence == null ? null
+            : Arrays.copyOf(sequence, sequence.length);
   }
 
   /*
@@ -682,7 +718,7 @@ public class Sequence extends ASequence implements SequenceI
   @Override
   public GeneLociI getGeneLoci()
   {
-    DBRefEntry[] refs = getDBRefs();
+    List<DBRefEntry> refs = getDBRefs();
     if (refs != null)
     {
       for (final DBRefEntry ref : refs)
@@ -852,7 +888,7 @@ public class Sequence extends ASequence implements SequenceI
     {
       return findPosition(column + 1, cursor);
     }
-    
+
     // TODO recode this more naturally i.e. count residues only
     // as they are found, not 'in anticipation'
 
@@ -1157,7 +1193,7 @@ public class Sequence extends ASequence implements SequenceI
   {
     ArrayList<int[]> map = new ArrayList<>();
     int lastj = -1, j = 0;
-    int pos = start;
+    // int pos = start;
     int seqlen = sequence.length;
     while ((j < seqlen))
     {
@@ -1191,7 +1227,7 @@ public class Sequence extends ASequence implements SequenceI
   {
     BitSet map = new BitSet();
     int lastj = -1, j = 0;
-    int pos = start;
+    // int pos = start;
     int seqlen = sequence.length;
     while ((j < seqlen))
     {
@@ -1359,24 +1395,22 @@ public class Sequence extends ASequence implements SequenceI
     vamsasId = id;
   }
 
+  @Deprecated
   @Override
-  public void setDBRefs(DBRefEntry[] dbref)
+  public void setDBRefs(DBModList<DBRefEntry> newDBrefs)
   {
     if (dbrefs == null && datasetSequence != null
             && this != datasetSequence)
     {
-      datasetSequence.setDBRefs(dbref);
+      datasetSequence.setDBRefs(newDBrefs);
       return;
     }
-    dbrefs = dbref;
-    if (dbrefs != null)
-    {
-      DBRefUtils.ensurePrimaries(this);
-    }
+    dbrefs = newDBrefs;
+    refModCount = 0;
   }
 
   @Override
-  public DBRefEntry[] getDBRefs()
+  public DBModList<DBRefEntry> getDBRefs()
   {
     if (dbrefs == null && datasetSequence != null
             && this != datasetSequence)
@@ -1389,6 +1423,7 @@ public class Sequence extends ASequence implements SequenceI
   @Override
   public void addDBRef(DBRefEntry entry)
   {
+    // TODO JAL-3980 maintain as sorted list
     if (datasetSequence != null)
     {
       datasetSequence.addDBRef(entry);
@@ -1397,12 +1432,13 @@ public class Sequence extends ASequence implements SequenceI
 
     if (dbrefs == null)
     {
-      dbrefs = new DBRefEntry[0];
+      dbrefs = new DBModList<>();
     }
+    // TODO JAL-3979 LOOK UP RATHER THAN SWEEP FOR EFFICIENCY
 
-    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
@@ -1412,18 +1448,19 @@ public class Sequence extends ASequence implements SequenceI
       }
     }
 
-    /*
-     * 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;
+    // /// 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;
 
-    DBRefUtils.ensurePrimaries(this);
+    dbrefs.add(entry);
   }
 
   @Override
@@ -1536,6 +1573,8 @@ public class Sequence extends ASequence implements SequenceI
 
   private int _seqhash = 0;
 
+  private List<DBRefEntry> primaryRefs;
+
   /**
    * Answers false if the sequence is more than 85% nucleotide (ACGTU), else
    * true
@@ -1553,7 +1592,7 @@ public class Sequence extends ASequence implements SequenceI
       _isNa = Comparison.isNucleotide(this);
     }
     return !_isNa;
-  };
+  }
 
   /*
    * (non-Javadoc)
@@ -1594,8 +1633,20 @@ public class Sequence extends ASequence implements SequenceI
           _aa.adjustForAlignment(); // uses annotation's own record of
                                     // sequence-column mapping
           datasetSequence.addAlignmentAnnotation(_aa);
+
+          if (_cmholder != null)
+          { // transfer contact matrices
+            ContactMatrixI cm = _cmholder.getContactMatrixFor(aa);
+            if (cm != null)
+            {
+              datasetSequence.addContactListFor(_aa, cm);
+              datasetSequence.addContactListFor(aa, cm);
+            }
+          }
         }
       }
+      // all matrices should have been transferred. so we clear the local holder
+      _cmholder=null;
     }
     return datasetSequence;
   }
@@ -1667,13 +1718,14 @@ public class Sequence extends ASequence implements SequenceI
       // 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()))
       {
         /*
@@ -1702,6 +1754,13 @@ public class Sequence extends ASequence implements SequenceI
       transferAnnotation(entry.getDatasetSequence(), mp);
       return;
     }
+    // transfer from entry to sequence
+    // if entry has a description and sequence doesn't, then transfer
+    if (entry.getDescription()!=null && (description==null || description.trim().length()==0))
+    {
+      description = entry.getDescription();
+    }
+    
     // transfer any new features from entry onto sequence
     if (entry.getSequenceFeatures() != null)
     {
@@ -1709,8 +1768,9 @@ public class Sequence extends ASequence implements SequenceI
       List<SequenceFeature> sfs = entry.getSequenceFeatures();
       for (SequenceFeature feature : sfs)
       {
-       SequenceFeature sf[] = (mp != null) ? mp.locateFeature(feature)
-                : new SequenceFeature[] { new SequenceFeature(feature) };
+        SequenceFeature sf[] = (mp != null) ? mp.locateFeature(feature)
+                : new SequenceFeature[]
+                { new SequenceFeature(feature) };
         if (sf != null)
         {
           for (int sfi = 0; sfi < sf.length; sfi++)
@@ -1732,12 +1792,12 @@ public class Sequence extends ASequence implements SequenceI
       }
     }
     // 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
@@ -1768,13 +1828,30 @@ public class Sequence extends ASequence implements SequenceI
   public List<AlignmentAnnotation> getAlignmentAnnotations(String calcId,
           String label)
   {
+    return getAlignmentAnnotations(calcId, label, null, true);
+  }
+
+  @Override
+  public List<AlignmentAnnotation> getAlignmentAnnotations(String calcId,
+          String label, String description)
+  {
+    return getAlignmentAnnotations(calcId, label, description, false);
+  }
+
+  private List<AlignmentAnnotation> getAlignmentAnnotations(String calcId,
+          String label, String description, boolean ignoreDescription)
+  {
     List<AlignmentAnnotation> result = new ArrayList<>();
     if (this.annotation != null)
     {
       for (AlignmentAnnotation ann : annotation)
       {
-        if (ann.calcId != null && ann.calcId.equals(calcId)
-                && ann.label != null && ann.label.equals(label))
+        if ((ann.calcId != null && ann.calcId.equals(calcId))
+                && (ann.label != null && ann.label.equals(label))
+                && ((ignoreDescription && description == null)
+                        || (ann.description != null
+                                && ann.description.equals(description))))
+
         {
           result.add(ann);
         }
@@ -1811,6 +1888,8 @@ public class Sequence extends ASequence implements SequenceI
     return null;
   }
 
+  private List<DBRefEntry> tmpList;
+
   @Override
   public List<DBRefEntry> getPrimaryDBRefs()
   {
@@ -1818,16 +1897,29 @@ public class Sequence extends ASequence implements SequenceI
     {
       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; // no changes
+      }
+      refModCount = dbrefs.getModCount();
+      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;
@@ -1842,8 +1934,8 @@ public class Sequence extends ASequence implements SequenceI
           }
         }
         // 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
@@ -1852,21 +1944,28 @@ public class Sequence extends ASequence implements SequenceI
           // 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])
+        else
         {
-          primaries.add(ref);
-          continue;
+          // 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);
       }
+
+      // version must be not null, as otherwise it will not be a candidate,
+      // above
+      DBRefUtils.ensurePrimaries(this, primaries);
       return primaries;
     }
   }
@@ -1884,15 +1983,6 @@ public class Sequence extends ASequence implements SequenceI
 
     List<SequenceFeature> result = getFeatures().findFeatures(startPos,
             endPos, types);
-    if (datasetSequence != null)
-    {
-      result = datasetSequence.getFeatures().findFeatures(startPos, endPos,
-              types);
-    }
-    else
-    {
-      result = sequenceFeatureStore.findFeatures(startPos, endPos, types);
-    }
 
     /*
      * if end column is gapped, endPos may be to the right, 
@@ -2044,4 +2134,83 @@ public class Sequence extends ASequence implements SequenceI
     // otherwise, sequence was completely hidden
     return 0;
   }
+
+  ////
+  //// Contact Matrix Holder Boilerplate
+  ////
+  ContactMapHolderI _cmholder = null;
+
+  private ContactMapHolderI getContactMapHolder()
+  {
+    if (datasetSequence!=null) {
+      return ((Sequence)datasetSequence).getContactMapHolder();
+    }
+    if (_cmholder==null)
+    {
+      _cmholder=new ContactMapHolder();
+    }
+    return _cmholder;
+  }
+  @Override
+  public Collection<ContactMatrixI> getContactMaps()
+  {
+    return getContactMapHolder().getContactMaps();
+  }
+
+  @Override
+  public ContactMatrixI getContactMatrixFor(AlignmentAnnotation ann)
+  {
+    return getContactMapHolder().getContactMatrixFor(ann);
+  }
+
+  @Override
+  public ContactListI getContactListFor(AlignmentAnnotation _aa, int column)
+  {
+    return getContactMapHolder().getContactListFor(_aa, column);
+  }
+
+  @Override
+  public AlignmentAnnotation addContactList(ContactMatrixI cm)
+  {
+    AlignmentAnnotation aa;
+    
+    if (datasetSequence != null)
+    {
+      aa = datasetSequence.addContactList(cm);
+      // clone the annotation for the local sequence
+      aa = new AlignmentAnnotation(aa);
+      aa.restrict(start, end);
+      aa.adjustForAlignment();
+      getContactMapHolder().addContactListFor(aa,cm);
+      addAlignmentAnnotation(aa);
+      return aa;
+    }
+    
+    // construct new annotation for matrix on dataset sequence
+    aa = getContactMapHolder().addContactList(cm);
+
+    Annotation _aa[] = new Annotation[getLength()];
+
+    for (int i = 0; i < _aa.length; _aa[i++] = new Annotation(0.0f))
+    {
+      ;
+    }
+    aa.annotations = _aa;
+    aa.setSequenceRef(this);
+    if (cm instanceof MappableContactMatrix
+            && !((MappableContactMatrix) cm).hasReferenceSeq())
+    {
+      ((MappableContactMatrix) cm).setRefSeq(this);
+    }
+    aa.createSequenceMapping(this, getStart(), false);
+    addAlignmentAnnotation(aa);
+    return aa;
+  }
+
+  @Override
+  public void addContactListFor(AlignmentAnnotation annotation,
+          ContactMatrixI cm)
+  {
+    getContactMapHolder().addContactListFor(annotation, cm);
+  }
 }