X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2Ffeatures%2FFeatureStore.java;h=b082b567471a1a6d55188ac84d9f49a8574e9d63;hb=c55e1fa5d2782cc46e515c11a91cf502f37386ab;hp=3e80966a50b4a9cd3a424750745f9bde3c268d8b;hpb=11d8f4cd92b8dc2fb2ee0b5f7757a6c2cdae813b;p=jalview.git

diff --git a/src/jalview/datamodel/features/FeatureStore.java b/src/jalview/datamodel/features/FeatureStore.java
index 3e80966..b082b56 100644
--- a/src/jalview/datamodel/features/FeatureStore.java
+++ b/src/jalview/datamodel/features/FeatureStore.java
@@ -33,6 +33,13 @@ public class FeatureStore
      */
     abstract boolean compare(SequenceFeature entry);
 
+    /**
+     * serves a search condition for finding the first feature whose start
+     * position follows a given target location
+     * 
+     * @param target
+     * @return
+     */
     static SearchCriterion byStart(final long target)
     {
       return new SearchCriterion() {
@@ -45,6 +52,13 @@ public class FeatureStore
       };
     }
 
+    /**
+     * serves a search condition for finding the first feature whose end
+     * position follows a given target location
+     * 
+     * @param target
+     * @return
+     */
     static SearchCriterion byEnd(final long target)
     {
       return new SearchCriterion()
@@ -58,6 +72,13 @@ public class FeatureStore
       };
     }
 
+    /**
+     * serves a search condition for finding the first feature which follows the
+     * given range as determined by a supplied comparator
+     * 
+     * @param target
+     * @return
+     */
     static SearchCriterion byFeature(final ContiguousI to,
             final Comparator<ContiguousI> rc)
     {
@@ -159,6 +180,11 @@ public class FeatureStore
    */
   public boolean addFeature(SequenceFeature feature)
   {
+    if (contains(feature))
+    {
+      return false;
+    }
+
     /*
      * keep a record of feature groups
      */
@@ -179,16 +205,13 @@ public class FeatureStore
     }
     else
     {
-      if (!contains(nonNestedFeatures, feature))
+      added = addNonNestedFeature(feature);
+      if (!added)
       {
-        added = addNonNestedFeature(feature);
-        if (!added)
-        {
-          /*
-           * detected a nested feature - put it in the NCList structure
-           */
-          added = addNestedFeature(feature);
-        }
+        /*
+         * detected a nested feature - put it in the NCList structure
+         */
+        added = addNestedFeature(feature);
       }
     }
 
@@ -225,6 +248,36 @@ public class FeatureStore
   }
 
   /**
+   * Answers true if this store contains the given feature (testing by
+   * SequenceFeature.equals), else false
+   * 
+   * @param feature
+   * @return
+   */
+  public boolean contains(SequenceFeature feature)
+  {
+    if (feature.isNonPositional())
+    {
+      return nonPositionalFeatures == null ? false : nonPositionalFeatures
+              .contains(feature);
+    }
+
+    if (feature.isContactFeature())
+    {
+      return contactFeatureStarts == null ? false : listContains(
+              contactFeatureStarts, feature);
+    }
+
+    if (listContains(nonNestedFeatures, feature))
+    {
+      return true;
+    }
+
+    return nestedFeatures == null ? false : nestedFeatures
+            .contains(feature);
+  }
+
+  /**
    * Answers the 'length' of the feature, counting 0 for non-positional features
    * and 1 for contact features
    * 
@@ -246,10 +299,10 @@ public class FeatureStore
 
   /**
    * Adds the feature to the list of non-positional features (with lazy
-   * instantiation of the list if it is null), and returns true. If the
-   * non-positional features already include the new feature (by equality test),
-   * then it is not added, and this method returns false. The feature group is
-   * added to the set of distinct feature groups for non-positional features.
+   * instantiation of the list if it is null), and returns true. The feature
+   * group is added to the set of distinct feature groups for non-positional
+   * features. This method allows duplicate features, so test before calling to
+   * prevent this.
    * 
    * @param feature
    */
@@ -259,10 +312,6 @@ public class FeatureStore
     {
       nonPositionalFeatures = new ArrayList<SequenceFeature>();
     }
-    if (nonPositionalFeatures.contains(feature))
-    {
-      return false;
-    }
 
     nonPositionalFeatures.add(feature);
 
@@ -281,7 +330,7 @@ public class FeatureStore
   {
     if (nestedFeatures == null)
     {
-      nestedFeatures = new NCList<SequenceFeature>(feature);
+      nestedFeatures = new NCList<>(feature);
       return true;
     }
     return nestedFeatures.add(feature, false);
@@ -362,8 +411,8 @@ public class FeatureStore
   /**
    * Add a contact feature to the lists that hold them ordered by start (first
    * contact) and by end (second contact) position, ensuring the lists remain
-   * ordered, and returns true. If the contact feature lists already contain the
-   * given feature (by test for equality), does not add it and returns false.
+   * ordered, and returns true. This method allows duplicate features to be
+   * added, so test before calling to avoid this.
    * 
    * @param feature
    * @return
@@ -379,11 +428,6 @@ public class FeatureStore
       contactFeatureEnds = new ArrayList<SequenceFeature>();
     }
 
-    if (contains(contactFeatureStarts, feature))
-    {
-      return false;
-    }
-
     /*
      * binary search the sorted list to find the insertion point
      */
@@ -412,7 +456,7 @@ public class FeatureStore
    * @param feature
    * @return
    */
-  protected static boolean contains(List<SequenceFeature> features,
+  protected static boolean listContains(List<SequenceFeature> features,
           SequenceFeature feature)
   {
     if (features == null || feature == null)
@@ -455,7 +499,7 @@ public class FeatureStore
    */
   public List<SequenceFeature> findOverlappingFeatures(long start, long end)
   {
-    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    List<SequenceFeature> result = new ArrayList<>();
 
     findNonNestedFeatures(start, end, result);
 
@@ -562,7 +606,7 @@ public class FeatureStore
    * Scans the list of non-nested features, starting from startIndex, to find
    * those that overlap the from-to range, and adds them to the result list.
    * Returns the index of the first feature whose start position is after the
-   * target range (or the length of the whole list if none such feature exists).
+   * target range (or the length of the whole list if no such feature exists).
    * 
    * @param startIndex
    * @param from
@@ -581,9 +625,7 @@ public class FeatureStore
       {
         break;
       }
-      int start = sf.getBegin();
-      int end = sf.getEnd();
-      if (start <= to && end >= from)
+      if (sf.getBegin() <= to && sf.getEnd() >= from)
       {
         result.add(sf);
       }
@@ -633,7 +675,7 @@ public class FeatureStore
     /*
      * add non-nested features (may be all features for many cases)
      */
-    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    List<SequenceFeature> result = new ArrayList<>();
     result.addAll(nonNestedFeatures);
 
     /*
@@ -667,7 +709,7 @@ public class FeatureStore
     {
       return Collections.emptyList();
     }
-    return new ArrayList<SequenceFeature>(contactFeatureStarts);
+    return new ArrayList<>(contactFeatureStarts);
   }
 
   /**
@@ -682,7 +724,7 @@ public class FeatureStore
     {
       return Collections.emptyList();
     }
-    return new ArrayList<SequenceFeature>(nonPositionalFeatures);
+    return new ArrayList<>(nonPositionalFeatures);
   }
 
   /**
@@ -972,7 +1014,7 @@ public class FeatureStore
   public List<SequenceFeature> getFeaturesForGroup(boolean positional,
           String group)
   {
-    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    List<SequenceFeature> result = new ArrayList<>();
 
     /*
      * if we know features don't include the target group, no need