src/jalview/bin/argparser/ArgValuesMap.java

   1 package jalview.bin.argparser;
   2
   3 import java.io.File;
   4 import java.util.ArrayList;
   5 import java.util.HashMap;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.Set;
   9
  10 import jalview.bin.argparser.Arg.Opt;
  11 import jalview.util.FileUtils;
  12
  13 /**
  14  * Helper class to allow easy extraction of information about specific argument
  15  * values (without having to check for null etc all the time)
  16  */
  17 public class ArgValuesMap
  18 {
  19   protected Map<Arg, ArgValues> m;
  20
  21   protected ArgValuesMap()
  22   {
  23     this.newMap();
  24   }
  25
  26   protected ArgValuesMap(Map<Arg, ArgValues> map)
  27   {
  28     this.m = map;
  29   }
  30
  31   private Map<Arg, ArgValues> getMap()
  32   {
  33     return m;
  34   }
  35
  36   private void newMap()
  37   {
  38     m = new HashMap<Arg, ArgValues>();
  39   }
  40
  41   private void newArg(Arg a)
  42   {
  43     if (m == null)
  44       newMap();
  45     if (!containsArg(a))
  46       m.put(a, new ArgValues(a));
  47   }
  48
  49   protected void addArgValue(Arg a, ArgValue av)
  50   {
  51     if (getMap() == null)
  52       m = new HashMap<Arg, ArgValues>();
  53
  54     if (!m.containsKey(a))
  55       m.put(a, new ArgValues(a));
  56     ArgValues avs = m.get(a);
  57     avs.addArgValue(av);
  58   }
  59
  60   public ArgValues getArgValues(Arg a)
  61   {
  62     return m == null ? null : m.get(a);
  63   }
  64
  65   public ArgValues getOrCreateArgValues(Arg a)
  66   {
  67     ArgValues avs = m.get(a);
  68     if (avs == null)
  69       newArg(a);
  70     return getArgValues(a);
  71   }
  72
  73   public List<ArgValue> getArgValueList(Arg a)
  74   {
  75     ArgValues avs = getArgValues(a);
  76     return avs == null ? new ArrayList<>() : avs.getArgValueList();
  77   }
  78
  79   public ArgValue getArgValue(Arg a)
  80   {
  81     List<ArgValue> vals = getArgValueList(a);
  82     return (vals == null || vals.size() == 0) ? null : vals.get(0);
  83   }
  84
  85   public String getValue(Arg a)
  86   {
  87     ArgValue av = getArgValue(a);
  88     return av == null ? null : av.getValue();
  89   }
  90
  91   public boolean containsArg(Arg a)
  92   {
  93     if (m == null || !m.containsKey(a))
  94       return false;
  95     return a.hasOption(Opt.STRING) ? getArgValue(a) != null : true;
  96   }
  97
  98   public boolean hasValue(Arg a, String val)
  99   {
 100     if (m == null || !m.containsKey(a))
 101       return false;
 102     for (ArgValue av : getArgValueList(a))
 103     {
 104       String avVal = av.getValue();
 105       if ((val == null && avVal == null)
 106               || (val != null && val.equals(avVal)))
 107       {
 108         return true;
 109       }
 110     }
 111     return false;
 112   }
 113
 114   public boolean getBoolean(Arg a)
 115   {
 116     ArgValues av = getArgValues(a);
 117     return av == null ? false : av.getBoolean();
 118   }
 119
 120   public Set<Arg> getArgKeys()
 121   {
 122     return m.keySet();
 123   }
 124
 125   public ArgValue getClosestPreviousArgValueOfArg(ArgValue thisAv, Arg a)
 126   {
 127     ArgValue closestAv = null;
 128     int thisArgIndex = thisAv.getArgIndex();
 129     ArgValues compareAvs = this.getArgValues(a);
 130     int closestPreviousIndex = -1;
 131     for (ArgValue av : compareAvs.getArgValueList())
 132     {
 133       int argIndex = av.getArgIndex();
 134       if (argIndex < thisArgIndex && argIndex > closestPreviousIndex)
 135       {
 136         closestPreviousIndex = argIndex;
 137         closestAv = av;
 138       }
 139     }
 140     return closestAv;
 141   }
 142
 143   public ArgValue getClosestNextArgValueOfArg(ArgValue thisAv, Arg a)
 144   {
 145     // this looks for the *next* arg that *might* be referring back to
 146     // a thisAv. Such an arg would have no subValues (if it does it should
 147     // specify an id in the subValues so wouldn't need to be guessed).
 148     ArgValue closestAv = null;
 149     int thisArgIndex = thisAv.getArgIndex();
 150     ArgValues compareAvs = this.getArgValues(a);
 151     int closestNextIndex = Integer.MAX_VALUE;
 152     for (ArgValue av : compareAvs.getArgValueList())
 153     {
 154       int argIndex = av.getArgIndex();
 155       if (argIndex > thisArgIndex && argIndex < closestNextIndex)
 156       {
 157         closestNextIndex = argIndex;
 158         closestAv = av;
 159       }
 160     }
 161     return closestAv;
 162   }
 163
 164   public ArgValue[] getArgValuesReferringTo(String key, String value, Arg a)
 165   {
 166     // this looks for the *next* arg that *might* be referring back to
 167     // a thisAv. Such an arg would have no subValues (if it does it should
 168     // specify an id in the subValues so wouldn't need to be guessed).
 169     List<ArgValue> avList = new ArrayList<>();
 170     Arg[] args = a == null ? (Arg[]) this.getMap().keySet().toArray()
 171             : new Arg[]
 172             { a };
 173     for (Arg keyArg : args)
 174     {
 175       for (ArgValue av : this.getArgValueList(keyArg))
 176       {
 177
 178       }
 179     }
 180     return (ArgValue[]) avList.toArray();
 181   }
 182
 183   public boolean hasId(Arg a, String id)
 184   {
 185     ArgValues avs = this.getArgValues(a);
 186     return avs == null ? false : avs.hasId(id);
 187   }
 188
 189   public ArgValue getId(Arg a, String id)
 190   {
 191     ArgValues avs = this.getArgValues(a);
 192     return avs == null ? null : avs.getId(id);
 193   }
 194
 195   /*
 196    * This method returns the basename of the first --append or --open value.
 197    * Used primarily for substitutions in output filenames.
 198    */
 199   public String getBasename()
 200   {
 201     return getDirOrBasename(false);
 202   }
 203
 204   /*
 205    * This method returns the dirname of the first --append or --open value.
 206    * Used primarily for substitutions in output filenames.
 207    */
 208   public String getDirname()
 209   {
 210     return getDirOrBasename(true);
 211   }
 212
 213   public String getDirOrBasename(boolean dirname)
 214   {
 215     String filename = null;
 216     String appendVal = getValue(Arg.APPEND);
 217     String openVal = getValue(Arg.OPEN);
 218     if (appendVal != null)
 219       filename = appendVal;
 220     if (filename == null && openVal != null)
 221       filename = openVal;
 222     if (filename == null)
 223       return null;
 224
 225     File file = new File(filename);
 226     return dirname ? FileUtils.getDirname(file)
 227             : FileUtils.getBasename(file);
 228   }
 229
 230   /*
 231    * Checks if there is an Arg with Opt
 232    */
 233   public boolean hasArgWithOption(Opt o)
 234   {
 235     for (Arg a : getArgKeys())
 236     {
 237       if (a.hasOption(o))
 238         return true;
 239     }
 240     return false;
 241   }
 242 }