/*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.giraph.benchmark;

 import org.apache.commons.cli.CommandLine;

 import org.apache.commons.cli.Options;

 import org.apache.log4j.Logger;

 /**

  * Command line options for benchmarks

  */

 public class BenchmarkOption {

   /** Option for help */

   public static final BenchmarkOption HELP =

       new BenchmarkOption("h", "help", false, "Help");

   /** Option for verbose */

   public static final BenchmarkOption VERBOSE =

       new BenchmarkOption("v", "verbose", false, "Verbose");

   /** Option for number of workers */

   public static final BenchmarkOption WORKERS =

       new BenchmarkOption("w", "workers", true, "Number of workers",

           "Need to choose the number of workers (-w)");

   /** Option for number of supersteps */

   public static final BenchmarkOption SUPERSTEPS =

       new BenchmarkOption("s", "supersteps", true,

           "Supersteps to execute before finishing",

           "Need to set the number of supersteps (-s)");

   /** Option for number of vertices */

   public static final BenchmarkOption VERTICES =

       new BenchmarkOption("V", "aggregateVertices", true,

           "Aggregate vertices", "Need to set the aggregate vertices (-V)");

   /** Option for number of edges per vertex */

   public static final BenchmarkOption EDGES_PER_VERTEX =

       new BenchmarkOption("e", "edgesPerVertex", true,

           "Edges per vertex",

           "Need to set the number of edges per vertex (-e)");

   /** Option for minimum ratio of partition-local edges */

   public static final BenchmarkOption LOCAL_EDGES_MIN_RATIO =

       new BenchmarkOption(

           "l", "localEdgesMinRatio", true,

           "Minimum ratio of partition-local edges (default is 0)");

   /** Option for using Jython */

   public static final BenchmarkOption JYTHON =

       new BenchmarkOption("j", "jython", false, "Use jython implementation");

   /** Option for path to script for computation */

   public static final BenchmarkOption SCRIPT_PATH =

       new BenchmarkOption("sp", "scriptPath", true,

           "Path to script for computation, can be local or HDFS path");

   /** Short option */

   private String shortOption;

   /** Long option */

   private String longOption;

   /** True iff option requires an argument */

   private boolean hasArgument;

   /** Description of the option */

   private String description;

   /**

    * Message to print if the option is missing, null if the option is not

    * required

    */

   private String missingMessage;

   /**

    * Constructor for option which is not required

    *

    * @param shortOption Short option

    * @param longOption Long option

    * @param hasArgument True iff option requires argument

    * @param description Description of the option

    */

   public BenchmarkOption(String shortOption, String longOption,

       boolean hasArgument, String description) {

     this(shortOption, longOption, hasArgument, description, null);

   }

   /**

    * Constructor for option which is not required

    *

    * @param shortOption Short option

    * @param longOption Long option

    * @param hasArgument True iff option requires argument

    * @param description Description of the option

    * @param missingMessage Message to print if the option is missing

    */

   public BenchmarkOption(String shortOption, String longOption,

       boolean hasArgument, String description, String missingMessage) {

     this.shortOption = shortOption;

     this.longOption = longOption;

     this.hasArgument = hasArgument;

     this.description = description;

     this.missingMessage = missingMessage;

   }

   /**

    * Check if the option is required

    *

    * @return True iff the option is required

    */

   public boolean isRequired() {

     return missingMessage != null;

   }

   /**

    * Add option to cli Options

    *

    * @param options Cli Options

    */

   public void addToOptions(Options options) {

     options.addOption(shortOption, longOption, hasArgument, description);

   }

   /**

    * If option is not required just return true.

    * If option is required, check if it's present in CommandLine,

    * and if it's not print the missingMessage to log.

    *

    * @param cmd CommandLine

    * @param log Logger to print the missing message to

    * @return False iff the option is required but is not specified in cmd

    */

   public boolean checkOption(CommandLine cmd, Logger log) {

     if (!isRequired()) {

       return true;

     }

     if (!cmd.hasOption(shortOption)) {

       log.info(missingMessage);

       return false;

     }

     return true;

   }

   /**

    * Check if the option is present in CommandLine

    *

    * @param cmd CommandLine

    * @return True iff the option is present in CommandLine

    */

   public boolean optionTurnedOn(CommandLine cmd) {

     return cmd.hasOption(shortOption);

   }

   /**

    * Retrieve the argument, if any, of this option

    *

    * @param cmd CommandLine

    * @return Value of the argument if option is set and has an argument,

    * otherwise null

    */

   public String getOptionValue(CommandLine cmd) {

     return cmd.getOptionValue(shortOption);

   }

   /**

    * Retrieve the argument of this option as integer value

    *

    * @param cmd CommandLine

    * @return Value of the argument as integer value

    */

   public int getOptionIntValue(CommandLine cmd) {

     return Integer.parseInt(getOptionValue(cmd));

   }

   /**

    * Retrieve the argument of this option as integer value,

    * or default value if option is not set

    *

    * @param cmd CommandLine

    * @param defaultValue Default value

    * @return Value of the argument as integer value,

    * or default value if option is not set

    */

   public int getOptionIntValue(CommandLine cmd, int defaultValue) {

     return optionTurnedOn(cmd) ? getOptionIntValue(cmd) : defaultValue;

   }

   /**

    * Retrieve the argument of this option as long value

    *

    * @param cmd CommandLine

    * @return Value of the argument as long value

    */

   public long getOptionLongValue(CommandLine cmd) {

     return Long.parseLong(getOptionValue(cmd));

   }

   /**

    * Retrieve the argument of this option as float value

    *

    * @param cmd CommandLine

    * @return Value of the argument as float value

    */

   public float getOptionFloatValue(CommandLine cmd) {

     return Float.parseFloat(getOptionValue(cmd));

   }

   /**

    * Retrieve the argument of this option as float value,

    * or default value if option is not set

    *

    * @param cmd CommandLine

    * @param defaultValue Default value

    * @return Value of the argument as float value,

    * or default value if option is not set

    */

   public float getOptionFloatValue(CommandLine cmd, float defaultValue) {

     return optionTurnedOn(cmd) ? getOptionFloatValue(cmd) : defaultValue;

   }

 }