runner/compbio/runner/OptionCombinator.java

   1 /* Copyright (c) 2011 Peter Troshin\r
   2  *  \r
   3  *  JAva Bioinformatics Analysis Web Services (JABAWS) @version: 2.0     \r
   4  * \r
   5  *  This library is free software; you can redistribute it and/or modify it under the terms of the\r
   6  *  Apache License version 2 as published by the Apache Software Foundation\r
   7  * \r
   8  *  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without\r
   9  *  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Apache \r
  10  *  License for more details.\r
  11  * \r
  12  *  A copy of the license is in apache_license.txt. It is also available here:\r
  13  * @see: http://www.apache.org/licenses/LICENSE-2.0.txt\r
  14  * \r
  15  * Any republication or derived work distributed in source code form\r
  16  * must include this copyright and license notice.\r
  17  */\r
  18 \r
  19 package compbio.runner;\r
  20 \r
  21 import java.util.ArrayList;\r
  22 import java.util.HashMap;\r
  23 import java.util.List;\r
  24 import java.util.Map;\r
  25 import java.util.Random;\r
  26 \r
  27 import org.apache.log4j.Logger;\r
  28 \r
  29 import compbio.engine.client.Executable;\r
  30 import compbio.metadata.Option;\r
  31 import compbio.metadata.Parameter;\r
  32 import compbio.metadata.RunnerConfig;\r
  33 import compbio.metadata.ValueConstrain;\r
  34 import compbio.util.Util;\r
  35 import compbio.util.annotation.Immutable;\r
  36 \r
  37 /**\r
  38  * This class solve the following problems. Given the RunnerConfig\r
  39  * \r
  40  * 1) generate a valid option string with all options and parameters in it\r
  41  * \r
  42  * 2) Permute all possible combinations of options order and parameters values\r
  43  * \r
  44  * \r
  45  * @author pvtroshin\r
  46  * \r
  47  */\r
  48 @Immutable\r
  49 public final class OptionCombinator {\r
  50 \r
  51     private static Logger log = Logger.getLogger(OptionCombinator.class);\r
  52     private static final String MINVALUE = "-100";\r
  53     private static final String MAXVALUE = "100";\r
  54 \r
  55     private static final Random rand = new Random();\r
  56     private final RunnerConfig<? extends Executable<?>> rconfig;\r
  57 \r
  58     public OptionCombinator(RunnerConfig<? extends Executable<?>> rconfig) {\r
  59         if (rconfig == null) {\r
  60             throw new IllegalArgumentException("RunnerConfig must be provided!");\r
  61         }\r
  62         this.rconfig = rconfig;\r
  63     }\r
  64 \r
  65     public List<String> optionsToCommandString(List<Option<?>> options) {\r
  66         List<String> strOptions = new ArrayList<String>();\r
  67         for (Option<?> option : options) {\r
  68             strOptions.add(optionToCommandString(option));\r
  69         }\r
  70         return strOptions;\r
  71     }\r
  72 \r
  73     public List<String> getOptionsAtRandom() {\r
  74         return optionsToCommandString(getAllOptions());\r
  75     }\r
  76 \r
  77     public List<Option<?>> getAllOptions() {\r
  78         return new ArrayList<Option<?>>(rconfig.getOptions());\r
  79     }\r
  80 \r
  81     static String optionToCommandString(Option<?> option) {\r
  82         int size = option.getOptionNames().size();\r
  83         int idx = rand.nextInt(size);\r
  84         return option.getOptionNames().get(idx);\r
  85     }\r
  86 \r
  87     public List<Parameter<?>> getAllParameters() {\r
  88         List<Parameter<?>> args = new ArrayList<Parameter<?>>();\r
  89         for (Parameter<?> prm : rconfig.getParameters()) {\r
  90             // Make sure there is a default value linked to the parameter to use\r
  91             // later\r
  92             // prm.setDefaultValue(getValue(prm));\r
  93             args.add(prm);\r
  94         }\r
  95         return args;\r
  96     }\r
  97 \r
  98     public List<String> argumentsToCommandString(\r
  99             List<? extends Option<?>> arguments) {\r
 100         return argumentsToCommandString(arguments, rconfig);\r
 101     }\r
 102 \r
 103     public static List<String> argumentsToCommandString(\r
 104             List<? extends Option<?>> arguments,\r
 105             RunnerConfig<? extends Executable<?>> rconfig) {\r
 106 \r
 107         if (arguments == null || rconfig == null) {\r
 108             throw new NullPointerException(\r
 109                     "Arguments and RunnerConfig objects must be provided!");\r
 110         }\r
 111 \r
 112         List<String> command = new ArrayList<String>();\r
 113         for (Option<?> option : arguments) {\r
 114 \r
 115             if (option instanceof Parameter<?>) {\r
 116                 Parameter<?> prm = (Parameter<?>) option;\r
 117                 command.add(prm.getOptionName() + rconfig.getPrmSeparator()\r
 118                         + getValue(prm));\r
 119                 log.trace("Setting parameter " + prm);\r
 120             } else {\r
 121                 log.trace("Setting option " + option);\r
 122                 command.add(optionToCommandString(option));\r
 123             }\r
 124         }\r
 125         return command;\r
 126     }\r
 127 \r
 128     public List<String> parametersToCommandString(\r
 129             List<Parameter<?>> orderedList, Map<Parameter<?>, String> prmValue) {\r
 130         List<String> args = new ArrayList<String>();\r
 131         for (Parameter<?> param : orderedList) {\r
 132             args.add(param.getOptionName() + rconfig.getPrmSeparator()\r
 133                     + prmValue.get(param));\r
 134         }\r
 135         return args;\r
 136     }\r
 137 \r
 138     public Map<Parameter<?>, String> getAllConstrainedParametersWithBorderValues(\r
 139             boolean minValue) {\r
 140         Map<Parameter<?>, String> paramValue = new HashMap<Parameter<?>, String>();\r
 141         for (Parameter<?> prm : rconfig.getParameters()) {\r
 142             ValueConstrain vc = prm.getValidValue();\r
 143             if (vc == null) {\r
 144                 continue;\r
 145             }\r
 146             String value = "";\r
 147             if (minValue) {\r
 148                 value = getLowBorderValue(prm);\r
 149             } else {\r
 150                 value = getUpperBorderValue(prm);\r
 151             }\r
 152             paramValue.put(prm, value);\r
 153         }\r
 154         return paramValue;\r
 155     }\r
 156 \r
 157     public Map<Parameter<?>, String> getAllConstrainedParametersWithRandomValues() {\r
 158         Map<Parameter<?>, String> paramValue = new HashMap<Parameter<?>, String>();\r
 159         for (Parameter<?> prm : rconfig.getParameters()) {\r
 160             ValueConstrain vc = prm.getValidValue();\r
 161             if (vc == null) {\r
 162                 continue;\r
 163             }\r
 164             paramValue.put(prm, getRandomValue(prm));\r
 165         }\r
 166         return paramValue;\r
 167     }\r
 168 \r
 169     String getLowBorderValue(Parameter<?> param) {\r
 170         assert param != null;\r
 171         ValueConstrain vc = param.getValidValue();\r
 172         Number minVal = vc.getMin();\r
 173         return minVal == null ? MINVALUE : minVal.toString();\r
 174     }\r
 175 \r
 176     String getUpperBorderValue(Parameter<?> param) {\r
 177         assert param != null;\r
 178         ValueConstrain vc = param.getValidValue();\r
 179         Number maxVal = vc.getMax();\r
 180         return maxVal == null ? MAXVALUE : maxVal.toString();\r
 181     }\r
 182 \r
 183     String getRandomValue(Parameter<?> param) {\r
 184         assert param != null;\r
 185         String low = getLowBorderValue(param);\r
 186         String high = getUpperBorderValue(param);\r
 187         ValueConstrain vc = param.getValidValue();\r
 188 \r
 189         if (vc.getType() == ValueConstrain.Type.Float) {\r
 190             return new Double(Util.getRandomNumber(Double.parseDouble(low),\r
 191                     Double.parseDouble(high))).toString();\r
 192         }\r
 193         return new Integer(Util.getRandomNumber(Integer.parseInt(low), Integer\r
 194                 .parseInt(high))).toString();\r
 195     }\r
 196 \r
 197     static String getValue(Parameter<?> param) {\r
 198         assert param != null;\r
 199         if (param.getDefaultValue() != null) {\r
 200             log.trace("Returning default value: " + param.getDefaultValue());\r
 201             return param.getDefaultValue();\r
 202         } else {\r
 203             // Some parameters do not have default values e.g. seq type - nuc or\r
 204             // protein\r
 205             List<String> passValues = param.getPossibleValues();\r
 206             int idx = rand.nextInt(passValues.size());\r
 207             log.trace("Returning random value: " + passValues.get(idx));\r
 208             return passValues.get(idx);\r
 209         }\r
 210     }\r
 211 }\r