JAL-4277 Corrected choice of all or last opened linkedIds. Better wildcard syntactic...

[jalview.git] / src / jalview / bin / argparser / ArgValuesMap.java

diff --git a/src/jalview/bin/argparser/ArgValuesMap.java b/src/jalview/bin/argparser/ArgValuesMap.java
index 22d85a8..4aa8570 100644 (file)
--- a/src/jalview/bin/argparser/ArgValuesMap.java
+++ b/src/jalview/bin/argparser/ArgValuesMap.java
@@ -1,5 +1,6 @@
 package jalview.bin.argparser;
 
+import java.io.File;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -7,6 +8,7 @@ import java.util.Map;
 import java.util.Set;
 
 import jalview.bin.argparser.Arg.Opt;
+import jalview.util.FileUtils;
 
 /**
  * Helper class to allow easy extraction of information about specific argument
@@ -16,16 +18,25 @@ public class ArgValuesMap
 {
   protected Map<Arg, ArgValues> m;
 
-  protected ArgValuesMap()
+  private String linkedId;
+
+  protected ArgValuesMap(String linkedId)
   {
+    this.linkedId = linkedId;
     this.newMap();
   }
 
-  protected ArgValuesMap(Map<Arg, ArgValues> map)
+  protected ArgValuesMap(String linkedId, Map<Arg, ArgValues> map)
   {
+    this.linkedId = linkedId;
     this.m = map;
   }
 
+  public String getLinkedId()
+  {
+    return linkedId;
+  }
+
   private Map<Arg, ArgValues> getMap()
   {
     return m;
@@ -44,17 +55,6 @@ public class ArgValuesMap
       m.put(a, new ArgValues(a));
   }
 
-  protected void addArgValue(Arg a, ArgValue av)
-  {
-    if (getMap() == null)
-      m = new HashMap<Arg, ArgValues>();
-
-    if (!m.containsKey(a))
-      m.put(a, new ArgValues(a));
-    ArgValues avs = m.get(a);
-    avs.addArgValue(av);
-  }
-
   public ArgValues getArgValues(Arg a)
   {
     return m == null ? null : m.get(a);
@@ -90,8 +90,7 @@ public class ArgValuesMap
   {
     if (m == null || !m.containsKey(a))
       return false;
-    return a.hasOption(Opt.STRING) ? getArgValue(a) != null
-            : this.getBoolean(a);
+    return a.hasOption(Opt.STRING) ? getArgValue(a) != null : true;
   }
 
   public boolean hasValue(Arg a, String val)
@@ -121,6 +120,33 @@ public class ArgValuesMap
     return m.keySet();
   }
 
+  public ArgValue getArgValueOfArgWithSubValKey(Arg a, String svKey)
+  {
+    return getArgValueOfArgWithSubValKey(a, svKey, false);
+  }
+
+  public ArgValue getArgValueOfArgWithSubValKey(Arg a, String svKey,
+          boolean last)
+  {
+    ArgValues avs = this.getArgValues(a);
+    if (avs == null)
+    {
+      return null;
+    }
+    List<ArgValue> compareAvs = avs.getArgValueList();
+    for (int i = 0; i < compareAvs.size(); i++)
+    {
+      int index = last ? compareAvs.size() - 1 - i : i;
+      ArgValue av = compareAvs.get(index);
+      SubVals sv = av.getSubVals();
+      if (sv.has(svKey) && !sv.get(svKey).equals("false"))
+      {
+        return av;
+      }
+    }
+    return null;
+  }
+
   public ArgValue getClosestPreviousArgValueOfArg(ArgValue thisAv, Arg a)
   {
     ArgValue closestAv = null;
@@ -146,6 +172,8 @@ public class ArgValuesMap
     // specify an id in the subValues so wouldn't need to be guessed).
     ArgValue closestAv = null;
     int thisArgIndex = thisAv.getArgIndex();
+    if (!containsArg(a))
+      return null;
     ArgValues compareAvs = this.getArgValues(a);
     int closestNextIndex = Integer.MAX_VALUE;
     for (ArgValue av : compareAvs.getArgValueList())
@@ -160,6 +188,7 @@ public class ArgValuesMap
     return closestAv;
   }
 
+  // TODO this is incomplete and currently unused (fortunately)
   public ArgValue[] getArgValuesReferringTo(String key, String value, Arg a)
   {
     // this looks for the *next* arg that *might* be referring back to
@@ -190,4 +219,66 @@ public class ArgValuesMap
     ArgValues avs = this.getArgValues(a);
     return avs == null ? null : avs.getId(id);
   }
+
+  /*
+   * This method returns the basename of the first --append or --open value. 
+   * Used primarily for substitutions in output filenames.
+   */
+  public String getBasename()
+  {
+    return getDirBasenameOrExtension(false, false, false);
+  }
+
+  /*
+   * This method returns the basename of the first --append or --open value. 
+   * Used primarily for substitutions in output filenames.
+   */
+  public String getExtension()
+  {
+    return getDirBasenameOrExtension(false, true, false);
+  }
+
+  /*
+   * This method returns the dirname of the first --append or --open value. 
+   * Used primarily for substitutions in output filenames.
+   */
+  public String getDirname()
+  {
+    return getDirBasenameOrExtension(true, false, false);
+  }
+
+  public String getDirBasenameOrExtension(boolean dirname,
+          boolean extension, boolean absoluteDirname)
+  {
+    String filename = null;
+    String appendVal = getValue(Arg.APPEND);
+    String openVal = getValue(Arg.OPEN);
+    if (appendVal != null)
+      filename = appendVal;
+    if (filename == null && openVal != null)
+      filename = openVal;
+    if (filename == null)
+      return null;
+
+    File file = new File(filename);
+    if (dirname)
+    {
+      return FileUtils.getDirname(file);
+    }
+    return extension ? FileUtils.getExtension(file)
+            : FileUtils.getBasename(file);
+  }
+
+  /*
+   * Checks if there is an Arg with Opt
+   */
+  public boolean hasArgWithOption(Opt o)
+  {
+    for (Arg a : getArgKeys())
+    {
+      if (a.hasOption(o))
+        return true;
+    }
+    return false;
+  }
 }