• Home
• io.vertx
• vertx-rx-java2
• 3.5.0
• source code
• CLI.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.vertx.reactivex.core.cli.CLI Maven / Gradle / Ivy

/*
 * Copyright 2014 Red Hat, Inc.
 *
 * Red Hat 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 io.vertx.reactivex.core.cli;

import java.util.Map;
import io.reactivex.Observable;
import io.reactivex.Flowable;
import io.reactivex.Single;
import io.reactivex.Completable;
import io.reactivex.Maybe;
import io.vertx.core.cli.Option;
import java.util.List;
import io.vertx.core.cli.Argument;

/**
 * Interface defining a command-line interface (in other words a command such as 'run', 'ls'...).
 * This interface is polyglot to ease reuse such as in Vert.x Shell.
 * 

 * A command line interface has a name, and defines a set of options and arguments. Options are key-value pair such
 * as -foo=bar or -flag. The supported formats depend on the used parser. Arguments are unlike
 * options raw values. Options are defined using
 * {@link io.vertx.core.cli.Option}, while argument are defined using {@link io.vertx.core.cli.Argument}.
 * 

 * Command line interfaces also define a summary and a description. These attributes are used in the usage generation
 * . To disable the help generation, set the hidden attribute to true.
 * 

 * Command Line Interface object does not contains "value", it's a model. It must be evaluated by a
 * parser that returns a {@link io.vertx.reactivex.core.cli.CommandLine} object containing the argument and option values.
 *
 * 

 * NOTE: This class has been automatically generated from the {@link io.vertx.core.cli.CLI original} non RX-ified interface using Vert.x codegen.
 */

@io.vertx.lang.reactivex.RxGen(io.vertx.core.cli.CLI.class)
public class CLI {

  @Override
  public String toString() {
    return delegate.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    CLI that = (CLI) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final io.vertx.lang.reactivex.TypeArg __TYPE_ARG = new io.vertx.lang.reactivex.TypeArg<>(
    obj -> new CLI((io.vertx.core.cli.CLI) obj),
    CLI::getDelegate
  );

  private final io.vertx.core.cli.CLI delegate;
  
  public CLI(io.vertx.core.cli.CLI delegate) {
    this.delegate = delegate;
  }

  public io.vertx.core.cli.CLI getDelegate() {
    return delegate;
  }

  /**
   * Creates an instance of {@link io.vertx.reactivex.core.cli.CLI} using the default implementation.
   * @param name the name of the CLI (must not be null)
   * @return the created instance of {@link io.vertx.reactivex.core.cli.CLI}
   */
  public static CLI create(String name) { 
    CLI ret = CLI.newInstance(io.vertx.core.cli.CLI.create(name));
    return ret;
  }

  /**
   * Parses the user command line interface and create a new {@link io.vertx.reactivex.core.cli.CommandLine} containing extracting values.
   * @param arguments the arguments
   * @return the creates command line
   */
  public CommandLine parse(List arguments) { 
    CommandLine ret = CommandLine.newInstance(delegate.parse(arguments));
    return ret;
  }

  /**
   * Parses the user command line interface and create a new {@link io.vertx.reactivex.core.cli.CommandLine} containing extracting values.
   * @param arguments the arguments
   * @param validate enable / disable parsing validation
   * @return the creates command line
   */
  public CommandLine parse(List arguments, boolean validate) { 
    CommandLine ret = CommandLine.newInstance(delegate.parse(arguments, validate));
    return ret;
  }

  /**
   * @return the CLI name.
   */
  public String getName() { 
    String ret = delegate.getName();
    return ret;
  }

  /**
   * Sets the name of the CLI.
   * @param name the name
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI setName(String name) { 
    delegate.setName(name);
    return this;
  }

  /**
   * @return the CLI description.
   */
  public String getDescription() { 
    String ret = delegate.getDescription();
    return ret;
  }

  public CLI setDescription(String desc) { 
    delegate.setDescription(desc);
    return this;
  }

  /**
   * @return the CLI summary.
   */
  public String getSummary() { 
    String ret = delegate.getSummary();
    return ret;
  }

  /**
   * Sets the summary of the CLI.
   * @param summary the summary
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI setSummary(String summary) { 
    delegate.setSummary(summary);
    return this;
  }

  /**
   * Checks whether or not the current {@link io.vertx.reactivex.core.cli.CLI} instance is hidden.
   * @return true if the current {@link io.vertx.reactivex.core.cli.CLI} is hidden,  otherwise
   */
  public boolean isHidden() { 
    boolean ret = delegate.isHidden();
    return ret;
  }

  /**
   * Sets whether or not the current instance of {@link io.vertx.reactivex.core.cli.CLI} must be hidden. Hidden CLI are not listed when
   * displaying usages / help messages. In other words, hidden commands are for power user.
   * @param hidden enables or disables the hidden aspect of the CI
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI setHidden(boolean hidden) { 
    delegate.setHidden(hidden);
    return this;
  }

  /**
   * Gets the list of options.
   * @return the list of options, empty if none.
   */
  public List getOptions() { 
    List ret = delegate.getOptions();
    return ret;
  }

  /**
   * Adds an option.
   * @param option the option, must not be null.
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI addOption(Option option) { 
    delegate.addOption(option);
    return this;
  }

  /**
   * Adds a set of options. Unlike {@link io.vertx.reactivex.core.cli.CLI#setOptions}}, this method does not remove the existing options.
   * The given list is appended to the existing list.
   * @param options the options, must not be null
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI addOptions(List options) { 
    delegate.addOptions(options);
    return this;
  }

  /**
   * Sets the list of arguments.
   * @param options the list of options, must not be null
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI setOptions(List options) { 
    delegate.setOptions(options);
    return this;
  }

  /**
   * Gets the list of defined arguments.
   * @return the list of argument, empty if none.
   */
  public List getArguments() { 
    List ret = delegate.getArguments();
    return ret;
  }

  /**
   * Adds an argument.
   * @param arg the argument, must not be null
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI addArgument(Argument arg) { 
    delegate.addArgument(arg);
    return this;
  }

  /**
   * Adds a set of arguments. Unlike {@link io.vertx.reactivex.core.cli.CLI#setArguments}, this method does not remove the existing arguments.
   * The given list is appended to the existing list.
   * @param args the arguments, must not be null
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI addArguments(List args) { 
    delegate.addArguments(args);
    return this;
  }

  /**
   * Sets the list of arguments.
   * @param args the list of arguments, must not be null
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI setArguments(List args) { 
    delegate.setArguments(args);
    return this;
  }

  /**
   * Gets an {@link io.vertx.core.cli.Option} based on its name (short name, long name or argument name).
   * @param name the name, must not be null
   * @return the {@link io.vertx.core.cli.Option}, null if not found
   */
  public Option getOption(String name) { 
    Option ret = delegate.getOption(name);
    return ret;
  }

  /**
   * Gets an {@link io.vertx.core.cli.Argument} based on its name (argument name).
   * @param name the name of the argument, must not be null
   * @return the {@link io.vertx.core.cli.Argument}, null if not found.
   */
  public Argument getArgument(String name) { 
    Argument ret = delegate.getArgument(name);
    return ret;
  }

  /**
   * Gets an {@link io.vertx.core.cli.Argument} based on its index.
   * @param index the index, must be positive or zero.
   * @return the {@link io.vertx.core.cli.Argument}, null if not found.
   */
  public Argument getArgument(int index) { 
    Argument ret = delegate.getArgument(index);
    return ret;
  }

  /**
   * Removes an option identified by its name. This method does nothing if the option cannot be found.
   * @param name the option name
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI removeOption(String name) { 
    delegate.removeOption(name);
    return this;
  }

  /**
   * Removes an argument identified by its index. This method does nothing if the argument cannot be found.
   * @param index the argument index
   * @return the current {@link io.vertx.reactivex.core.cli.CLI} instance
   */
  public CLI removeArgument(int index) { 
    delegate.removeArgument(index);
    return this;
  }


  public static  CLI newInstance(io.vertx.core.cli.CLI arg) {
    return arg != null ? new CLI(arg) : null;
  }
}