X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2FArgParser.java;h=be2c07f1f3f02705f55180ddc865aeccd52d2e63;hb=156ab6ab1046c02dc327c2ac986afa336f0bbf3b;hp=877a7f6c0f96ddc17b6a51d046608f6f322c8ba9;hpb=6860179ce5f69173f230c05bd5fe6e85c73886a3;p=jalview.git

diff --git a/src/jalview/bin/ArgParser.java b/src/jalview/bin/ArgParser.java
index 877a7f6..be2c07f 100644
--- a/src/jalview/bin/ArgParser.java
+++ b/src/jalview/bin/ArgParser.java
@@ -23,6 +23,7 @@ package jalview.bin;
 import java.net.URLDecoder;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.Enumeration;
@@ -59,7 +60,7 @@ public class ArgParser
     USAGESTATS, OPEN, OPEN2, PROPS, QUESTIONNAIRE, SETPROP, TREE, VDOC,
     VSESS, OUTPUT, OUTPUTTYPE, SSANNOTATION, NOTEMPFAC, TEMPFAC,
     TEMPFAC_LABEL, TEMPFAC_DESC, TEMPFAC_SHADING, TITLE, PAEMATRIX, WRAP,
-    NOSTRUCTURE, STRUCTURE, IMAGE, QUIT;
+    NOSTRUCTURE, STRUCTURE, IMAGE, QUIT, DEBUG("d");
 
     static
     {
@@ -103,7 +104,7 @@ public class ArgParser
       TEMPFAC.setOptions(Opt.STRING, Opt.LINKED);
       TEMPFAC_LABEL.setOptions(Opt.STRING, Opt.LINKED);
       TEMPFAC_DESC.setOptions(Opt.STRING, Opt.LINKED);
-      TEMPFAC_SHADING.setOptions(Opt.STRING, Opt.LINKED);
+      TEMPFAC_SHADING.setOptions(Opt.BOOLEAN, Opt.LINKED);
       TITLE.setOptions(Opt.STRING, Opt.LINKED);
       PAEMATRIX.setOptions(Opt.STRING, Opt.LINKED, Opt.MULTI);
       NOSTRUCTURE.setOptions(Opt.UNARY, Opt.LINKED);
@@ -111,6 +112,7 @@ public class ArgParser
       WRAP.setOptions(Opt.BOOLEAN, Opt.LINKED);
       IMAGE.setOptions(Opt.STRING, Opt.LINKED);
       QUIT.setOptions(Opt.UNARY);
+      DEBUG.setOptions(Opt.BOOLEAN);
     }
 
     private final String[] argNames;
@@ -213,12 +215,16 @@ public class ArgParser
 
     private boolean negated = false;
 
-    private List<String> argsList;
+    private int singleArgIndex = -1;
+
+    private List<Integer> argsIndexes;
+
+    private List<ArgValue> argsList;
 
     protected ArgValues(Arg a)
     {
       this.arg = a;
-      this.argsList = new ArrayList<String>();
+      this.argsList = new ArrayList<ArgValue>();
       this.boolValue = arg.getDefaultBoolValue();
     }
 
@@ -272,8 +278,9 @@ public class ArgParser
       {
         sb.append("Values:");
         boolean first = true;
-        for (String v : argsList)
+        for (ArgValue av : argsList)
         {
+          String v = av.getValue();
           if (!first)
             sb.append(",");
           sb.append("\n  '");
@@ -288,25 +295,24 @@ public class ArgParser
 
     protected void addValue()
     {
-      addValue(null);
+      addValue(null, -1);
     }
 
-    protected void addValue(String val)
+    protected void addValue(String val, int argIndex)
     {
-      addValue(val, false);
+      addValue(val, argIndex, false);
     }
 
-    protected void addValue(String val, boolean noDuplicates)
+    protected void addValue(String val, int argIndex, boolean noDuplicates)
     {
       if ((!arg.hasOption(Opt.MULTI) && argsList.size() > 0)
               || (noDuplicates && argsList.contains(val)))
         return;
       if (argsList == null)
       {
-        Console.warn("** inst");
-        argsList = new ArrayList<String>();
+        argsList = new ArrayList<ArgValue>();
       }
-      argsList.add(val);
+      argsList.add(new ArgValue(val, argIndex));
     }
 
     protected boolean hasValue(String val)
@@ -314,14 +320,22 @@ public class ArgParser
       return argsList.contains(val);
     }
 
-    protected String getValue()
+    protected ArgValue getArgValue()
     {
       if (arg.hasOption(Opt.MULTI))
         Console.warn("Requesting single value for multi value argument");
       return argsList.size() > 0 ? argsList.get(0) : null;
     }
 
-    protected List<String> getValues()
+    /*
+    protected String getValue()
+    {
+    ArgValue av = getArgValue();
+    return av == null ? null : av.getValue();
+    }
+    */
+
+    protected List<ArgValue> getArgValueList()
     {
       return argsList;
     }
@@ -454,6 +468,7 @@ public class ArgParser
 
     // new style
     Enumeration<String> argE = Collections.enumeration(Arrays.asList(args));
+    int argIndex = 0;
     while (argE.hasMoreElements())
     {
       String arg = argE.nextElement();
@@ -555,7 +570,7 @@ public class ArgParser
         // store appropriate value
         if (a.hasOption(Opt.STRING))
         {
-          values.addValue(val);
+          values.addValue(val, argIndex);
         }
         else if (a.hasOption(Opt.BOOLEAN))
         {
@@ -669,33 +684,35 @@ public class ArgParser
     return sb.toString();
   }
 
-  // Helper methods with safety checks
-  protected static ArgValues getArgValues(Map<Arg, ArgValues> m, Arg a)
+  public static SubVals getSubVals(String item)
   {
-    return m == null ? null : m.get(a);
+    return new SubVals(item);
   }
 
-  public static List<String> getValues(Map<Arg, ArgValues> m, Arg a)
+  /**
+   * A helper class to keep an index of argument position with argument values
+   */
+  public static class ArgValue
   {
-    ArgValues av = getArgValues(m, a);
-    return av == null ? null : av.getValues();
-  }
+    private int argIndex;
 
-  public static String getValue(Map<Arg, ArgValues> m, Arg a)
-  {
-    List<String> vals = getValues(m, a);
-    return (vals == null || vals.size() == 0) ? null : vals.get(0);
-  }
+    private String value;
 
-  public static boolean getBoolean(Map<Arg, ArgValues> m, Arg a)
-  {
-    ArgValues av = getArgValues(m, a);
-    return av == null ? false : av.getBoolean();
-  }
+    protected ArgValue(String value, int argIndex)
+    {
+      this.value = value;
+      this.argIndex = argIndex;
+    }
 
-  public static SubVal getSubVal(String item)
-  {
-    return new SubVal(item);
+    protected String getValue()
+    {
+      return value;
+    }
+
+    protected int getArgIndex()
+    {
+      return argIndex;
+    }
   }
 
   /**
@@ -704,50 +721,60 @@ public class ArgParser
    * the strings keyName and keyValue, and the content after the square brackets
    * (if present). Values not set `will be -1 or null.
    */
-  public static class SubVal
+  public static class SubVals
   {
     private static int NOTSET = -1;
 
-    protected int index = NOTSET;
+    private int index = NOTSET;
 
-    protected String keyName = null;
+    private Map<String, String> subVals = null;
 
-    protected String keyValue = null;
+    private static char SEPARATOR = ';';
 
-    protected String content = null;
+    private String content = null;
 
-    public SubVal(String item)
+    public SubVals(String item)
     {
-      this.parseVal(item);
+      this.parseVals(item);
     }
 
-    public void parseVal(String item)
+    public void parseVals(String item)
     {
       if (item.indexOf('[') == 0 && item.indexOf(']') > 1)
       {
         int openBracket = item.indexOf('[');
         int closeBracket = item.indexOf(']');
-        String indexString = item.substring(openBracket + 1, closeBracket);
+        String subvalsString = item.substring(openBracket + 1,
+                closeBracket);
         this.content = item.substring(closeBracket + 1);
-        int equals = indexString.indexOf('=');
-        if (equals > -1)
+        boolean setIndex = false;
+        for (String subvalString : subvalsString
+                .split(Character.toString(SEPARATOR)))
         {
-          this.keyName = indexString.substring(0, equals);
-          this.keyValue = indexString.substring(equals + 1);
-          this.index = -1;
-        }
-        else
-        {
-          try
+          int equals = subvalString.indexOf('=');
+          if (equals > -1)
           {
-            this.index = Integer.parseInt(indexString);
-          } catch (NumberFormatException e)
+            if (subVals == null)
+              subVals = new HashMap<>();
+            subVals.put(subvalString.substring(0, equals),
+                    subvalString.substring(equals + 1));
+          }
+          else
           {
-            Console.warn("Failed to obtain subvalue or index from '" + item
-                    + "'. Setting index=0 and using content='" + content
-                    + "'.");
+            try
+            {
+              this.index = Integer.parseInt(subvalString);
+              setIndex = true;
+            } catch (NumberFormatException e)
+            {
+              Console.warn("Failed to obtain subvalue or index from '"
+                      + item + "'. Setting index=0 and using content='"
+                      + content + "'.");
+            }
           }
         }
+        if (!setIndex)
+          this.index = NOTSET;
       }
       else
       {
@@ -758,7 +785,130 @@ public class ArgParser
     public boolean notSet()
     {
       // notSet is true if content present but nonsensical
-      return index == NOTSET && keyName == null && keyValue == null;
+      return index == NOTSET && subVals == null;
+    }
+
+    public String get(String key)
+    {
+      return subVals == null ? null : subVals.get(key);
+    }
+
+    public boolean has(String key)
+    {
+      return subVals == null ? false : subVals.containsKey(key);
+    }
+
+    public int getIndex()
+    {
+      return index;
+    }
+
+    public String getContent()
+    {
+      return content;
+    }
+  }
+
+  /**
+   * Helper class to allow easy extraction of information about specific
+   * argument values (without having to check for null etc all the time)
+   */
+  protected static class ArgValuesMap
+  {
+    protected Map<Arg, ArgValues> m;
+
+    protected ArgValuesMap(Map<Arg, ArgValues> map)
+    {
+      this.m = map;
+    }
+
+    protected ArgValues getArgValues(Arg a)
+    {
+      return m == null ? null : m.get(a);
+    }
+
+    protected List<ArgValue> getArgValueList(Arg a)
+    {
+      ArgValues av = getArgValues(a);
+      return av == null ? null : av.getArgValueList();
+    }
+
+    protected ArgValue getArgValue(Arg a)
+    {
+      List<ArgValue> vals = getArgValueList(a);
+      return (vals == null || vals.size() == 0) ? null : vals.get(0);
+    }
+
+    protected String getValue(Arg a)
+    {
+      ArgValue av = getArgValue(a);
+      return av == null ? null : av.getValue();
+    }
+
+    protected boolean hasValue(Arg a)
+    {
+      if (!m.containsKey(a))
+        return false;
+      return getArgValue(a) != null;
+    }
+
+    protected boolean getBoolean(Arg a)
+    {
+      ArgValues av = getArgValues(a);
+      return av == null ? false : av.getBoolean();
+    }
+
+    protected ArgValue getClosestPreviousArgValueOfArg(ArgValue thisAv,
+            Arg a)
+    {
+      ArgValue closestAv = null;
+      int thisArgIndex = thisAv.getArgIndex();
+      ArgValues compareAvs = this.getArgValues(a);
+      int closestPreviousIndex = -1;
+      for (ArgValue av : compareAvs.getArgValueList())
+      {
+        int argIndex = av.getArgIndex();
+        if (argIndex < thisArgIndex && argIndex > closestPreviousIndex)
+        {
+          closestPreviousIndex = argIndex;
+          closestAv = av;
+        }
+      }
+      return closestAv;
+    }
+  }
+
+  private static final Collection<Arg> bootstrapArgs = new ArrayList(
+          Arrays.asList(Arg.PROPS, Arg.DEBUG));
+
+  public static Map<Arg, String> bootstrapArgs(String[] args)
+  {
+    Map<Arg, String> bootstrapArgMap = new HashMap<>();
+    if (args == null)
+      return bootstrapArgMap;
+    Enumeration<String> argE = Collections.enumeration(Arrays.asList(args));
+    while (argE.hasMoreElements())
+    {
+      String arg = argE.nextElement();
+      String argName = null;
+      String val = null;
+      if (arg.startsWith("--"))
+      {
+        int equalPos = arg.indexOf('=');
+        if (equalPos > -1)
+        {
+          argName = arg.substring(2, equalPos);
+          val = arg.substring(equalPos + 1);
+        }
+        else
+        {
+          argName = arg.substring(2);
+        }
+        Arg a = argMap.get(argName);
+        if (a != null && bootstrapArgs.contains(a))
+          bootstrapArgMap.put(a, val);
+      }
     }
+    return bootstrapArgMap;
   }
 }
\ No newline at end of file