JAL-2446 added getFeatureGroups

[jalview.git] / src / jalview / datamodel / features / SequenceFeatures.java

diff --git a/src/jalview/datamodel/features/SequenceFeatures.java b/src/jalview/datamodel/features/SequenceFeatures.java
index d177566..a61eff2 100644 (file)
--- a/src/jalview/datamodel/features/SequenceFeatures.java
+++ b/src/jalview/datamodel/features/SequenceFeatures.java
@@ -2,16 +2,28 @@ package jalview.datamodel.features;
 
 import jalview.datamodel.SequenceFeature;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
+/**
+ * A class that stores sequence features in a way that supports efficient
+ * querying by type and location (overlap). Intended for (but not limited to)
+ * storage of features for one sequence.
+ * 
+ * @author gmcarstairs
+ *
+ */
 public class SequenceFeatures
 {
 
   /*
    * map from feature type to structured store of features for that type
+   * null types are permitted (but not a good idea!)
    */
   private Map<String, FeatureStore> featureStore;
 
@@ -24,18 +36,22 @@ public class SequenceFeatures
   }
 
   /**
-   * Add one sequence feature to the store
+   * Adds one sequence feature to the store, and returns true, unless the
+   * feature is already contained in the store, in which case this method
+   * returns false. Containment is determined by SequenceFeature.equals()
+   * comparison.
    * 
    * @param sf
    */
-  public void add(SequenceFeature sf)
+  public boolean add(SequenceFeature sf)
   {
     String type = sf.getType();
+
     if (featureStore.get(type) == null)
     {
       featureStore.put(type, new FeatureStore());
     }
-    featureStore.get(type).addFeature(sf);
+    return featureStore.get(type).addFeature(sf);
   }
 
   /**
@@ -57,4 +73,156 @@ public class SequenceFeatures
     }
     return features.findOverlappingFeatures(from, to);
   }
+
+  /**
+   * Answers a list of all features stored (including non-positional), in no
+   * particular guaranteed order
+   * 
+   * @return
+   */
+  public List<SequenceFeature> getFeatures()
+  {
+    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    for (FeatureStore featureSet : featureStore.values())
+    {
+      result.addAll(featureSet.getFeatures());
+    }
+    return result;
+  }
+
+  /**
+   * Answers a list of all non-positional features stored, in no particular
+   * guaranteed order
+   * 
+   * @return
+   */
+  public List<SequenceFeature> getNonPositionalFeatures()
+  {
+    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    for (FeatureStore featureSet : featureStore.values())
+    {
+      result.addAll(featureSet.getNonPositionalFeatures());
+    }
+    return result;
+  }
+
+  /**
+   * Answers a list of all contact features stored, in no particular guaranteed
+   * order
+   * 
+   * @return
+   */
+  public List<SequenceFeature> getContactFeatures()
+  {
+    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    for (FeatureStore featureSet : featureStore.values())
+    {
+      result.addAll(featureSet.getContactFeatures());
+    }
+    return result;
+  }
+
+  /**
+   * Answers a list of all features of the given type (including
+   * non-positional), in no particular guaranteed order
+   * 
+   * @return
+   */
+  public List<SequenceFeature> getFeatures(String type)
+  {
+    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    FeatureStore featureSet = featureStore.get(type);
+    if (featureSet != null)
+    {
+      result.addAll(featureSet.getFeatures());
+    }
+    return result;
+  }
+
+  /**
+   * Answers a list of all contact features of the given type, in no particular
+   * guaranteed order
+   * 
+   * @return
+   */
+  public List<SequenceFeature> getContactFeatures(String type)
+  {
+    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    FeatureStore featureSet = featureStore.get(type);
+    if (featureSet != null)
+    {
+      result.addAll(featureSet.getContactFeatures());
+    }
+    return result;
+  }
+
+  /**
+   * Answers a list of all non-positional features of the given type, in no
+   * particular guaranteed order
+   * 
+   * @return
+   */
+  public List<SequenceFeature> getNonPositionalFeatures(String type)
+  {
+    List<SequenceFeature> result = new ArrayList<SequenceFeature>();
+    FeatureStore featureSet = featureStore.get(type);
+    if (featureSet != null)
+    {
+      result.addAll(featureSet.getNonPositionalFeatures());
+    }
+    return result;
+  }
+
+  /**
+   * Deletes the given feature from the store, returning true if it was found
+   * (and deleted), else false. This method makes no assumption that the feature
+   * is in the 'expected' place in the store, in case it has been modified since
+   * it was added.
+   * 
+   * @param sf
+   */
+  public boolean delete(SequenceFeature sf)
+  {
+    for (FeatureStore featureSet : featureStore.values())
+    {
+      if (featureSet.delete(sf))
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Answers true if this store contains at least one feature, else false
+   * 
+   * @return
+   */
+  public boolean hasFeatures()
+  {
+    for (FeatureStore featureSet : featureStore.values())
+    {
+      if (!featureSet.isEmpty())
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns a set of the distinct feature groups present in the collection. The
+   * set may include null.
+   * 
+   * @return
+   */
+  public Set<String> getFeatureGroups()
+  {
+    Set<String> groups = new HashSet<String>();
+    for (FeatureStore featureSet : featureStore.values())
+    {
+      groups.addAll(featureSet.getFeatureGroups());
+    }
+    return groups;
+  }
 }