| /* | |
| * 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.oodt.cas.cli.util; | |
| //JDK imports | |
| import java.io.File; | |
| import java.net.MalformedURLException; | |
| import java.net.URL; | |
| import java.util.Collections; | |
| import java.util.Comparator; | |
| import java.util.LinkedList; | |
| import java.util.List; | |
| import java.util.Set; | |
| //OODT imports | |
| import org.apache.commons.lang.StringUtils; | |
| import org.apache.commons.lang.Validate; | |
| import org.apache.oodt.cas.cli.action.CmdLineAction; | |
| import org.apache.oodt.cas.cli.option.ActionCmdLineOption; | |
| import org.apache.oodt.cas.cli.option.AdvancedCmdLineOption; | |
| import org.apache.oodt.cas.cli.option.CmdLineOption; | |
| import org.apache.oodt.cas.cli.option.CmdLineOptionInstance; | |
| import org.apache.oodt.cas.cli.option.GroupCmdLineOption; | |
| import org.apache.oodt.cas.cli.option.GroupSubOption; | |
| import org.apache.oodt.cas.cli.option.HandleableCmdLineOption; | |
| import org.apache.oodt.cas.cli.option.HelpCmdLineOption; | |
| import org.apache.oodt.cas.cli.option.PrintSupportedActionsCmdLineOption; | |
| import org.apache.oodt.cas.cli.option.SimpleCmdLineOption; | |
| import org.apache.oodt.cas.cli.option.ValidatableCmdLineOption; | |
| import org.apache.oodt.cas.cli.option.require.RequirementRule; | |
| import org.apache.oodt.cas.cli.option.require.RequirementRule.Relation; | |
| import org.apache.oodt.cas.cli.option.validator.CmdLineOptionValidator; | |
| //Google imports | |
| import com.google.common.collect.Lists; | |
| import com.google.common.collect.Sets; | |
| /** | |
| * Collection of common helper methods. | |
| * | |
| * @author bfoster (Brian Foster) | |
| */ | |
| public class CmdLineUtils { | |
| private CmdLineUtils() { | |
| } | |
| /** | |
| * Determines which of the given {@link CmdLineOption}s are either always | |
| * required and are required because the given {@link CmdLineAction} was | |
| * specified. | |
| * | |
| * @param action | |
| * The {@link CmdLineAction} which was specified. | |
| * @param options | |
| * The {@link CmdLineOption}s in question of being required or not. | |
| * @return The {@link Set} of {@link CmdLineOption}s which are either always | |
| * required or are required because the given {@link CmdLineAction} | |
| * was specified. | |
| */ | |
| public static Set<CmdLineOption> determineRequired(CmdLineAction action, | |
| Set<CmdLineOption> options) { | |
| return determineRequired(action, options, false); | |
| } | |
| /** | |
| * Same as method above but optionally allows action options to be ignored. | |
| */ | |
| public static Set<CmdLineOption> determineRequired(CmdLineAction action, | |
| Set<CmdLineOption> options, boolean ignoreActionOption) { | |
| Validate.notNull(action); | |
| Validate.notNull(options); | |
| Set<CmdLineOption> requiredOptions = Sets.newHashSet(); | |
| for (CmdLineOption option : options) { | |
| if (!(ignoreActionOption && isActionOption(option)) | |
| && isRequired(action, option)) { | |
| requiredOptions.add(option); | |
| } | |
| } | |
| return requiredOptions; | |
| } | |
| /** | |
| * Determines the given {@link GroupCmdLineOption}'s sub-options which | |
| * affect the given {@link CmdLineAction}. | |
| * | |
| * @param action | |
| * The {@link CmdLineAction} for which given | |
| * {@link GroupCmdLineOption}'s sub-options will be determined | |
| * relevant or not | |
| * @param option | |
| * The {@link GroupCmdLineOption} whose sub-options are in question | |
| * of being relevant to the given {@link CmdLineAction} | |
| * @return The {@link GroupCmdLineOption}'s sub-options who are relevant to | |
| * given {@link CmdLineAction} | |
| */ | |
| public static Set<CmdLineOption> determineRelevantSubOptions( | |
| CmdLineAction action, GroupCmdLineOption option) { | |
| Set<CmdLineOption> relevantOptions = Sets.newHashSet(); | |
| for (GroupSubOption subOption : option.getSubOptions()) { | |
| if (subOption.getOption().getRequirementRules().isEmpty() | |
| || isRequired(action, subOption.getOption()) | |
| || isStrictlyOptional(action, subOption.getOption())) { | |
| relevantOptions.add(subOption.getOption()); | |
| } | |
| } | |
| return relevantOptions; | |
| } | |
| /** | |
| * Determines the sub-options of given {@link GroupCmdLineOption} who are | |
| * always required. | |
| * | |
| * @param option | |
| * The {@link GroupCmdLineOption} whose sub-options are check where | |
| * they are required | |
| * @return The required sub-options of given {@link GroupCmdLineOption} | |
| */ | |
| public static Set<CmdLineOption> determineRequiredSubOptions( | |
| GroupCmdLineOption option) { | |
| Validate.notNull(option); | |
| Set<CmdLineOption> requiredOptions = Sets.newHashSet(); | |
| for (GroupSubOption subOption : option.getSubOptions()) { | |
| if (subOption.isRequired()) { | |
| requiredOptions.add(subOption.getOption()); | |
| } | |
| } | |
| return requiredOptions; | |
| } | |
| /** | |
| * Determines the sub-options of given {@link GroupCmdLineOption} who are | |
| * either always required for become requried when given | |
| * {@link CmdLineAction} is specified. | |
| * | |
| * @param action | |
| * The specified {@link CmdLineAction} | |
| * @param option | |
| * The {@link GroupCmdLineOption} whose sub-options are checked if | |
| * they are required | |
| * @return The given {@link GroupCmdLineOption}'s required sub-options | |
| */ | |
| public static Set<CmdLineOption> determineRequiredSubOptions( | |
| CmdLineAction action, GroupCmdLineOption option) { | |
| Validate.notNull(action); | |
| Validate.notNull(option); | |
| Set<CmdLineOption> requiredOptions = Sets.newHashSet(); | |
| for (GroupSubOption subOption : option.getSubOptions()) { | |
| if (subOption.isRequired() | |
| || isRequired(action, subOption.getOption())) { | |
| requiredOptions.add(subOption.getOption()); | |
| } | |
| } | |
| return requiredOptions; | |
| } | |
| /** | |
| * Determines if the given {@link CmdLineOption} is required because the | |
| * given {@link CmdLineAction} was specified or because it is always required. | |
| * | |
| * @param action | |
| * The {@link CmdLineAction} which was specified. | |
| * @param option | |
| * The {@link CmdLineOption} in question of being required or not. | |
| * @return True is option is required, false otherwise. | |
| */ | |
| public static boolean isRequired(CmdLineAction action, CmdLineOption option) { | |
| Validate.notNull(option); | |
| Validate.notNull(action); | |
| for (RequirementRule requirementRule : option.getRequirementRules()) { | |
| if (requirementRule.getRelation(action) == Relation.REQUIRED) { | |
| return true; | |
| } | |
| } | |
| return option.getRequirementRules().isEmpty() && option.isRequired(); | |
| } | |
| /** | |
| * Determines which of the given {@link CmdLineOption}s are optional because | |
| * the given {@link CmdLineAction} was specified. | |
| * | |
| * @param action | |
| * The {@link CmdLineAction} which was specified. | |
| * @param options | |
| * The {@link CmdLineOption} in question of being optional or not. | |
| * @return The {@link Set} of {@link CmdLineOption}s where are optional | |
| * because the given {@link CmdLineAction} was specified. | |
| */ | |
| public static Set<CmdLineOption> determineOptional(CmdLineAction action, | |
| Set<CmdLineOption> options) { | |
| Validate.notNull(action); | |
| Validate.notNull(options); | |
| Set<CmdLineOption> optionalOptions = Sets.newHashSet(); | |
| for (CmdLineOption option : options) { | |
| if (isOptional(action, option)) { | |
| optionalOptions.add(option); | |
| } | |
| } | |
| return optionalOptions; | |
| } | |
| /** | |
| * Determines if the given {@link CmdLineOption} is optional either because | |
| * it is always optional or because the given {@link CmdLineAction} was | |
| * specified. | |
| * | |
| * @param action | |
| * The {@link CmdLineAction} which was specified. | |
| * @param option | |
| * The {@link CmdLineOption} in question of being optional or not. | |
| * @return True is option is optional, false otherwise. | |
| */ | |
| public static boolean isOptional(CmdLineAction action, CmdLineOption option) { | |
| Validate.notNull(action); | |
| Validate.notNull(option); | |
| if (isPerformAndQuitOption(option)) { | |
| return false; | |
| } | |
| for (RequirementRule requirementRule : option.getRequirementRules()) { | |
| if (requirementRule.getRelation(action) == Relation.OPTIONAL) { | |
| return true; | |
| } | |
| } | |
| return option.getRequirementRules().isEmpty() && !option.isRequired(); | |
| } | |
| /** | |
| * Determines if the given {@link CmdLineOption} is optional ONLY because the | |
| * given {@link CmdLineAction} was specified. | |
| * | |
| * @param action | |
| * The {@link CmdLineAction} which was specified. | |
| * @param option | |
| * The {@link CmdLineOption} in question of being optional or not. | |
| * @return True is option is optional, false otherwise. | |
| */ | |
| public static boolean isStrictlyOptional(CmdLineAction action, CmdLineOption option) { | |
| Validate.notNull(action); | |
| Validate.notNull(option); | |
| if (isPerformAndQuitOption(option)) { | |
| return false; | |
| } | |
| for (RequirementRule requirementRule : option.getRequirementRules()) { | |
| if (requirementRule.getRelation(action) == Relation.OPTIONAL) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * Get {@link CmdLineOption}s which are always required regardless of | |
| * {@link CmdLineAction} specified. NOTE: Ignores {@link CmdLineOption}s of | |
| * type {@link ActionCmdLineOption}. | |
| * | |
| * @param options | |
| * The {@link CmdLineOption}S to check for required | |
| * {@link CmdLineOption}s | |
| * @return The {@link CmdLineOption}s which will be check for always required | |
| * {@link CmdLineOption}s | |
| */ | |
| public static Set<CmdLineOption> getRequiredOptions( | |
| Set<CmdLineOption> options) { | |
| Validate.notNull(options); | |
| return getRequiredOptions(options, true); | |
| } | |
| /** | |
| * Get {@link CmdLineOption}s which are always required regardless of | |
| * {@link CmdLineAction} specified. | |
| * | |
| * @param options | |
| * The {@link CmdLineOption}S to check for required | |
| * {@link CmdLineOption}s | |
| * @param ignoreActionOption | |
| * Where or not to ignore {@link CmdLineOption}s of type | |
| * {@link ActionCmdLineOption} | |
| * @return The {@link CmdLineOption}s which will be check for always required | |
| * {@link CmdLineOption}s | |
| */ | |
| public static Set<CmdLineOption> getRequiredOptions( | |
| Set<CmdLineOption> options, boolean ignoreActionOption) { | |
| Validate.notNull(options); | |
| Set<CmdLineOption> requiredOptions = Sets.newHashSet(); | |
| for (CmdLineOption option : options) { | |
| if (option.isRequired() | |
| && !(isActionOption(option) && ignoreActionOption)) { | |
| requiredOptions.add(option); | |
| } | |
| } | |
| return requiredOptions; | |
| } | |
| /** | |
| * Sorts {@link CmdLineOption}s by requirement levels. {@link CmdLineOption}s | |
| * which are always required have highest sort score, followed by | |
| * {@link CmdLineOption}s which have {@link RequirementRule}s, followed by | |
| * all others. | |
| * | |
| * @param options | |
| * The {@link Set} of {@link CmdLineOption}s to sort. | |
| * @return The {@link CmdLineOption}s sorted by requirement. | |
| */ | |
| public static List<CmdLineOption> sortOptionsByRequiredStatus( | |
| Set<CmdLineOption> options) { | |
| Validate.notNull(options); | |
| List<CmdLineOption> optionsList = Lists.newArrayList(options); | |
| Collections.sort(optionsList, new Comparator<CmdLineOption>() { | |
| public int compare(CmdLineOption option1, CmdLineOption option2) { | |
| int thisScore = (option1.isRequired() ? 2 : 0) | |
| + (!option1.getRequirementRules().isEmpty() ? 1 : 0); | |
| int compareScore = (option2.isRequired() ? 2 : 0) | |
| + (!option2.getRequirementRules().isEmpty() ? 1 : 0); | |
| if (thisScore == compareScore) { | |
| return option2.getLongOption() | |
| .compareTo(option1.getLongOption()); | |
| } else { | |
| return new Integer(thisScore).compareTo(compareScore); | |
| } | |
| } | |
| }); | |
| Collections.reverse(optionsList); | |
| return optionsList; | |
| } | |
| /** | |
| * Sorts {@link CmdLineOption}s by there long name. | |
| * | |
| * @param options The {@link CmdLineOption}s to be sorted | |
| * @return Sorted {@link List} of {@link CmdLineOption}s | |
| */ | |
| public static List<CmdLineOption> sortOptions(Set<CmdLineOption> options) { | |
| List<CmdLineOption> optionList = Lists.newArrayList(options); | |
| Collections.sort(optionList, new Comparator<CmdLineOption>() { | |
| @Override | |
| public int compare(CmdLineOption o1, CmdLineOption o2) { | |
| return o1.getLongOption().compareTo(o2.getLongOption()); | |
| } | |
| }); | |
| return optionList; | |
| } | |
| /** | |
| * Sorts {@link CmdLineAction}s by there name. | |
| * | |
| * @param actions The {@link CmdLineAction}s to be sorted | |
| * @return Sorted {@link List} of {@link CmdLineAction}s | |
| */ | |
| public static List<CmdLineAction> sortActions(Set<CmdLineAction> actions) { | |
| List<CmdLineAction> actionsList = Lists.newArrayList(actions); | |
| Collections.sort(actionsList, new Comparator<CmdLineAction>() { | |
| @Override | |
| public int compare(CmdLineAction a1, CmdLineAction a2) { | |
| return a1.getName().compareTo(a2.getName()); | |
| } | |
| }); | |
| return actionsList; | |
| } | |
| /** | |
| * Finds {@link CmdLineOption} whose short name or long name equals given | |
| * option name. | |
| * | |
| * @param optionName | |
| * The short or long name of the {@link CmdLineOption} to find | |
| * @param options | |
| * The {@link CmdLineOption}s to search in | |
| * @return The {@link CmdLineOption} found or null if not found. | |
| */ | |
| public static CmdLineOption getOptionByName(String optionName, | |
| Set<CmdLineOption> options) { | |
| Validate.notNull(optionName); | |
| Validate.notNull(options); | |
| for (CmdLineOption option : options) { | |
| if (option.getLongOption().equals(optionName) | |
| || option.getShortOption().equals(optionName)) { | |
| return option; | |
| } else if (isGroupOption(option)) { | |
| Set<CmdLineOption> subOptions = Sets.newHashSet(); | |
| for (GroupSubOption subOption : asGroupOption(option).getSubOptions()) { | |
| subOptions.add(subOption.getOption()); | |
| } | |
| CmdLineOption foundOption = getOptionByName(optionName, subOptions); | |
| if (foundOption != null) { | |
| return foundOption; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| /** | |
| * Finds {@link CmdLineOptionInstance} whose {@link CmdLineOption}'s short | |
| * name or long name equals given option name. | |
| * | |
| * @param optionName | |
| * The short or long name of the {@link CmdLineOptionInstance}'s | |
| * {@link CmdLineOption} to find | |
| * @param optionInsts | |
| * The {@link CmdLineOptionIntance}s to search in | |
| * @return The {@link CmdLineOptionInstance} found or null if not found. | |
| */ | |
| public static CmdLineOptionInstance getOptionInstanceByName( | |
| String optionName, Set<CmdLineOptionInstance> optionInsts) { | |
| Validate.notNull(optionName); | |
| Validate.notNull(optionInsts); | |
| for (CmdLineOptionInstance optionInst : optionInsts) | |
| if (optionInst.getOption().getLongOption().equals(optionName) | |
| || optionInst.getOption().getShortOption().equals(optionName)) | |
| return optionInst; | |
| return null; | |
| } | |
| /** | |
| * Checks if given {@link CmdLineOption} is a sub-option of other given | |
| * {@link CmdLineOption}. | |
| * | |
| * @param option | |
| * {@link CmdLineOption} which is being checked if the other given | |
| * {@link CmdLineOption} is one of its sub-options | |
| * @param subOption | |
| * The {@link CmdLineOption} which is being check if it is a | |
| * sub-option of the other given {@link CmdLineOption} | |
| * @return True if subOption is a sub-option of option | |
| */ | |
| public static boolean isSubOption(CmdLineOption option, | |
| CmdLineOption subOption) { | |
| Validate.notNull(option); | |
| Validate.notNull(subOption); | |
| if (isGroupOption(option)) { | |
| for (GroupSubOption curSubOption : asGroupOption(option) | |
| .getSubOptions()) { | |
| if (curSubOption.getOption().equals(subOption)) { | |
| return true; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * Finds all the perform-and-quit type {@link CmdLineOptionInstance}s from | |
| * the given {@link Set} of {@link CmdLineOptionInstance}s. | |
| * | |
| * @param options | |
| * The {@link Set} of {@link CmdLineOptionInstance} who will be | |
| * check for perform-and-quit {@link CmdLineOptionInstance}s | |
| * @return The perform-and-quit {@link CmdLineOptionInstance}s found | |
| */ | |
| public static Set<CmdLineOptionInstance> findPerformAndQuitOptions( | |
| Set<CmdLineOptionInstance> options) { | |
| Validate.notNull(options); | |
| Set<CmdLineOptionInstance> performAndQuitOptions = Sets.newHashSet(); | |
| for (CmdLineOptionInstance option : options) { | |
| if (isPerformAndQuitOption(option.getOption())) { | |
| performAndQuitOptions.add(option); | |
| } | |
| } | |
| return performAndQuitOptions; | |
| } | |
| /** | |
| * Checks if the given {@link CmdLineOption} is a perform-and-quit type | |
| * {@link CmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} being checked if it is | |
| * perform-and-quit type. | |
| * @return True if {@link CmdLineOption} is a perform-and-quit type, false | |
| * otherwise. | |
| */ | |
| public static boolean isPerformAndQuitOption(CmdLineOption option) { | |
| Validate.notNull(option); | |
| if (isHelpOption(option) || isPrintSupportedActionsOption(option)) { | |
| return true; | |
| } else if (isAdvancedOption(option)) { | |
| return asAdvancedOption(option).isPerformAndQuit(); | |
| } else { | |
| return false; | |
| } | |
| } | |
| /** | |
| * Finds the first {@link CmdLineOptionInstance} whose {@link CmdLineOption} | |
| * is the given {@link CmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} to find. | |
| * @param specifiedOptions | |
| * The {@link CmdLineOptionInstance} whose {@link CmdLineOption} is | |
| * the given {@link CmdLineOption} | |
| * @return The first {@link CmdLineOptionInstance} whose | |
| * {@link CmdLineOption} is the given {@link CmdLineOption}, or null | |
| * if not found | |
| */ | |
| public static CmdLineOptionInstance findSpecifiedOption( | |
| CmdLineOption option, Set<CmdLineOptionInstance> specifiedOptions) { | |
| Validate.notNull(option); | |
| Validate.notNull(specifiedOptions); | |
| for (CmdLineOptionInstance specifiedOption : specifiedOptions) { | |
| if (specifiedOption.getOption().equals(option)) { | |
| return specifiedOption; | |
| } | |
| } | |
| return null; | |
| } | |
| /** | |
| * Finds the {@link CmdLineOptionInstance}s whose {@link CmdLineOption} is | |
| * the given {@link CmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} to find. | |
| * @param specifiedOptions | |
| * The {@link CmdLineOptionInstance} whose {@link CmdLineOption} is | |
| * the given {@link CmdLineOption} | |
| * @return The {@link CmdLineOptionInstance}s whose {@link CmdLineOption} is | |
| * the given {@link CmdLineOption} | |
| */ | |
| public static Set<CmdLineOptionInstance> findAllOfSpecifiedOption( | |
| CmdLineOption option, Set<CmdLineOptionInstance> specifiedOptions) { | |
| Validate.notNull(option); | |
| Validate.notNull(specifiedOptions); | |
| Set<CmdLineOptionInstance> options = Sets.newHashSet(); | |
| for (CmdLineOptionInstance specifiedOption : specifiedOptions) { | |
| if (specifiedOption.getOption().equals(option)) { | |
| options.add(specifiedOption); | |
| } | |
| } | |
| return options; | |
| } | |
| /** | |
| * Checks if {@link CmdLineOption} is a {@link PrintSupportedActionsOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} in question | |
| * @return True is {@link CmdLineOption} is a | |
| * {@link PrintSupportedActionsOption}, false otherwise | |
| */ | |
| public static boolean isPrintSupportedActionsOption(CmdLineOption option) { | |
| Validate.notNull(option); | |
| return option instanceof PrintSupportedActionsCmdLineOption; | |
| } | |
| /** | |
| * Finds {@link CmdLineOption} of type | |
| * {@link PrintSupportedActionsCmdLineOption}. | |
| * | |
| * @param options | |
| * The {@link Set} of {@link CmdLineOption} to find a | |
| * {@link PrintSupportedActionsCmdLineOption} in | |
| * @return The found {@link PrintSupportedActionsCmdLineOption}, or null if | |
| * not found. | |
| */ | |
| public static PrintSupportedActionsCmdLineOption findPrintSupportedActionsOption( | |
| Set<CmdLineOption> options) { | |
| Validate.notNull(options); | |
| for (CmdLineOption option : options) { | |
| if (isPrintSupportedActionsOption(option)) { | |
| return (PrintSupportedActionsCmdLineOption) option; | |
| } | |
| } | |
| return null; | |
| } | |
| /** | |
| * Finds {@link CmdLineOptionInstance} whose {@link CmdLineOption} of type | |
| * {@link PrintSupportedActionsCmdLineOption}. | |
| * | |
| * @param options | |
| * The {@link Set} of {@link CmdLineOptionInstance} to find the | |
| * {@link CmdLineOptionInstance} whose {@link CmdLineOption} is of | |
| * type {@link PrintSupportedActionsCmdLineOption} in | |
| * @throws IllegalArgumentException | |
| * If more than one print supported actions option is specified | |
| * @return The found {@link CmdLineOptionInstance} whose | |
| * {@link CmdLineOption} is of type | |
| * {@link PrintSupportedActionsCmdLineOption}, or null if not found. | |
| */ | |
| public static CmdLineOptionInstance findSpecifiedPrintSupportedActionsOption( | |
| Set<CmdLineOptionInstance> options) { | |
| Validate.notNull(options); | |
| CmdLineOptionInstance specifiedPsa = null; | |
| for (CmdLineOptionInstance option : options) { | |
| if (isPrintSupportedActionsOption(option.getOption())) { | |
| if (specifiedPsa != null) { | |
| throw new IllegalArgumentException( | |
| "Only on print supported actions option can be specified!"); | |
| } | |
| specifiedPsa = option; | |
| } | |
| } | |
| return specifiedPsa; | |
| } | |
| /** | |
| * Checks if {@link CmdLineOption} is a {@link AdvancedCmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} checked if it is a | |
| * {@link AdvancedCmdLineOption} | |
| * @return True if {@link CmdLineOption} is a {@link AdvancedCmdLineOption}, | |
| * false otherwise | |
| */ | |
| public static boolean isAdvancedOption(CmdLineOption option) { | |
| Validate.notNull(option); | |
| return option instanceof AdvancedCmdLineOption; | |
| } | |
| /** | |
| * Casts the {@link CmdLineOption} to a {@link AdvancedCmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} to cast as a | |
| * {@link AdvancedCmdLineOption} | |
| * @return The casted {@link CmdLineOption} | |
| */ | |
| public static AdvancedCmdLineOption asAdvancedOption(CmdLineOption option) { | |
| Validate.isTrue(isAdvancedOption(option)); | |
| return (AdvancedCmdLineOption) option; | |
| } | |
| /** | |
| * Checks if {@link CmdLineOption} is a {@link SimpleCmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} checked if it is a | |
| * {@link SimpleCmdLineOption} | |
| * @return True if {@link CmdLineOption} is a {@link SimpleCmdLineOption}, | |
| * false otherwise | |
| */ | |
| public static boolean isSimpleOption(CmdLineOption option) { | |
| Validate.notNull(option); | |
| return option instanceof SimpleCmdLineOption; | |
| } | |
| /** | |
| * Casts the {@link CmdLineOption} to a {@link SimpleCmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} to cast as a | |
| * {@link SimpleCmdLineOption} | |
| * @return The casted {@link CmdLineOption} | |
| */ | |
| public static SimpleCmdLineOption asSimpleOption(CmdLineOption option) { | |
| Validate.isTrue(isSimpleOption(option)); | |
| return (SimpleCmdLineOption) option; | |
| } | |
| /** | |
| * Checks if {@link CmdLineOption} is a {@link ActionCmdLineOption}. | |
| * | |
| * @param option | |
| * {@link CmdLineOption} check if a {@link ActionCmdLineOption} | |
| * @return True if {@link CmdLineOption} is a {@link ActionCmdLineOption}, | |
| * false otherwise | |
| */ | |
| public static boolean isActionOption(CmdLineOption option) { | |
| Validate.notNull(option); | |
| return option instanceof ActionCmdLineOption; | |
| } | |
| /** | |
| * Find {@link ActionCmdLineOption} in {@link Set} of {@link CmdLineOption}s. | |
| * | |
| * @param options | |
| * The {@link Set} of {@link CmdLineOption} to search through for a | |
| * {@link ActionCmdLineOption} | |
| * @return The found {@link ActionCmdLineOption}, or null if not found | |
| */ | |
| public static ActionCmdLineOption findFirstActionOption( | |
| Set<CmdLineOption> options) { | |
| Validate.notNull(options); | |
| for (CmdLineOption option : options) { | |
| if (isActionOption(option)) { | |
| return (ActionCmdLineOption) option; | |
| } else if (isGroupOption(option)) { | |
| GroupCmdLineOption groupOption = (GroupCmdLineOption) option; | |
| Set<CmdLineOption> subOptions = Sets.newHashSet(); | |
| for (GroupSubOption subOption : groupOption.getSubOptions()) { | |
| subOptions.add(subOption.getOption()); | |
| } | |
| ActionCmdLineOption foundOption = findFirstActionOption(subOptions); | |
| if (foundOption != null) { | |
| return foundOption; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| /** | |
| * Finds all {@link CmdLineOption}s that are {@link ActionCmdLineOption}s. | |
| * | |
| * @param options | |
| * The {@link CmdLineOption}s to look through for | |
| * {@link ActionCmdLineOption}s | |
| * @return All {@link ActionCmdLineOption}s found | |
| */ | |
| public static List<ActionCmdLineOption> findActionOptions( | |
| Set<CmdLineOption> options) { | |
| Validate.notNull(options); | |
| List<ActionCmdLineOption> actionOptions = Lists.newArrayList(); | |
| for (CmdLineOption option : options) { | |
| if (isActionOption(option)) { | |
| actionOptions.add((ActionCmdLineOption) option); | |
| } else if (isGroupOption(option)) { | |
| GroupCmdLineOption groupOption = (GroupCmdLineOption) option; | |
| Set<CmdLineOption> subOptions = Sets.newHashSet(); | |
| for (GroupSubOption subOption : groupOption.getSubOptions()) { | |
| subOptions.add(subOption.getOption()); | |
| } | |
| actionOptions.addAll(findActionOptions(subOptions)); | |
| } | |
| } | |
| return actionOptions; | |
| } | |
| /** | |
| * Find {@link ActionCmdLineOption} in {@link Set} of {@link CmdLineOption}s. | |
| * | |
| * @param options | |
| * The {@link Set} of {@link CmdLineOption} to search through for a | |
| * {@link ActionCmdLineOption} | |
| * @throws IllegalArgumentException | |
| * If more than one action option has be specified | |
| * @return The found {@link ActionCmdLineOption}, or null if not found | |
| */ | |
| public static CmdLineOptionInstance findSpecifiedActionOption( | |
| Set<CmdLineOptionInstance> options) { | |
| Validate.notNull(options); | |
| CmdLineOptionInstance specifiedAction = null; | |
| for (CmdLineOptionInstance option : options) { | |
| if (option.isAction()) { | |
| if (specifiedAction != null) { | |
| throw new IllegalArgumentException( | |
| "Only one action may be specified!"); | |
| } | |
| specifiedAction = option; | |
| } else if (option.isGroup()) { | |
| CmdLineOptionInstance foundAction = findSpecifiedActionOption(option | |
| .getSubOptions()); | |
| if (specifiedAction != null && foundAction != null) { | |
| throw new IllegalArgumentException( | |
| "Only one action may be specified!"); | |
| } else if (foundAction != null) { | |
| specifiedAction = foundAction; | |
| } | |
| } | |
| } | |
| return specifiedAction; | |
| } | |
| /** | |
| * Checks if {@link CmdLineOption} is a {@link GroupCmdLineOption}. | |
| * | |
| * @param option | |
| * {@link CmdLineOption} in question | |
| * @return True if {@link CmdLineOption} is a {@link GroupCmdLineOption}, | |
| * false otherwise | |
| */ | |
| public static boolean isGroupOption(CmdLineOption option) { | |
| Validate.notNull(option); | |
| return option instanceof GroupCmdLineOption; | |
| } | |
| /** | |
| * Cast {@link CmdLineOption} to a {@link GroupCmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} to be cast as a | |
| * {@link GroupCmdLineOption} | |
| * @return A {@link GroupCmdLineOption} | |
| */ | |
| public static GroupCmdLineOption asGroupOption(CmdLineOption option) { | |
| Validate.isTrue(isGroupOption(option)); | |
| return (GroupCmdLineOption) option; | |
| } | |
| /** | |
| * Checks if {@link CmdLineOption} is a {@link HelpCmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} that is checked if it is a | |
| * {@link HelpCmdLineOption} | |
| * @return True if {@link CmdLineOption} is a {@link HelpCmdLineOption}, | |
| * otherwise false | |
| */ | |
| public static boolean isHelpOption(CmdLineOption option) { | |
| Validate.notNull(option); | |
| return option instanceof HelpCmdLineOption; | |
| } | |
| /** | |
| * Casts {@link CmdLineOption} to a {@link HelpCmdLineOption}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOption} to be cast as a | |
| * {@link HelpCmdLineOption} | |
| * @return A {@link HelpCmdLineOption} | |
| */ | |
| public static HelpCmdLineOption asHelpOption(CmdLineOption option) { | |
| Validate.isTrue(isHelpOption(option)); | |
| return (HelpCmdLineOption) option; | |
| } | |
| /** | |
| * Finds the {@link HelpCmdLineOption} in the {@link Set} of | |
| * {@link CmdLineOption}s. | |
| * | |
| * @param options | |
| * The {@link Set} of {@link CmdLineOption}s to search through for | |
| * {@link HelpCmdLineOption} | |
| * @return The found {@link HelpCmdLineOption}, null if not found | |
| */ | |
| public static HelpCmdLineOption findHelpOption(Set<CmdLineOption> options) { | |
| Validate.notNull(options); | |
| for (CmdLineOption option : options) { | |
| if (isHelpOption(option)) { | |
| return (HelpCmdLineOption) option; | |
| } | |
| } | |
| return null; | |
| } | |
| /** | |
| * Finds the {@link CmdLineOptionInstance} whose {@link CmdLineOption} is of | |
| * type {@link HelpCmdLineOption} | |
| * | |
| * @param options | |
| * The {@link Set} of {@link CmdLineOptionInstance}s to search | |
| * through for the {@link CmdLineOptionInstance} whose | |
| * {@link CmdLineOption} is of type {@link HelpCmdLineOption} | |
| * @throws IllegalArgumentException | |
| * If more than one help option is specified | |
| * @return The found {@link CmdLineOptionInstance}, null if not found | |
| */ | |
| public static CmdLineOptionInstance findSpecifiedHelpOption( | |
| Set<CmdLineOptionInstance> options) { | |
| Validate.notNull(options); | |
| CmdLineOptionInstance specifiedHelp = null; | |
| for (CmdLineOptionInstance option : options) { | |
| if (isHelpOption(option.getOption())) { | |
| if (specifiedHelp != null) { | |
| throw new IllegalArgumentException( | |
| "Help can only be specified once!"); | |
| } | |
| specifiedHelp = option; | |
| } | |
| } | |
| return specifiedHelp; | |
| } | |
| /** | |
| * Finds the {@link CmdLineAction} specified by the given | |
| * {@link CmdLineOptionInstance}. | |
| * | |
| * @param actionOption | |
| * The {@link CmdLineOptionInstance} which specifies an | |
| * {@link ActionCmdLineOption} | |
| * @param supportedActions | |
| * {@link Set} of supported {@link CmdLineAction}s | |
| * @return The found {@link CmdLineAction}, null if not found | |
| */ | |
| public static CmdLineAction findAction(CmdLineOptionInstance actionOption, | |
| Set<CmdLineAction> supportedActions) { | |
| Validate.isTrue(actionOption.isAction()); | |
| Validate.notEmpty(actionOption.getValues()); | |
| Validate.notNull(supportedActions); | |
| return findAction(actionOption.getValues().get(0), supportedActions); | |
| } | |
| /** | |
| * Finds a {@link CmdLineAction} by its name. | |
| * | |
| * @param actionName | |
| * Name of {@link CmdLineAction} to find | |
| * @param supportedActions | |
| * {@link Set} of supported {@link CmdLineAction}s | |
| * @return Found {@link CmdLineAction} or null if not found | |
| */ | |
| public static CmdLineAction findAction(String actionName, | |
| Set<CmdLineAction> supportedActions) { | |
| Validate.notNull(actionName); | |
| Validate.notNull(supportedActions); | |
| for (CmdLineAction action : supportedActions) { | |
| if (action.getName().equals(actionName)) { | |
| return action; | |
| } | |
| } | |
| return null; | |
| } | |
| /** | |
| * Validates the given {@link CmdLineOptionInstance}. | |
| * | |
| * @param option | |
| * The {@link CmdLineOptionInstance} to be validated | |
| * @return {@link CmdLineOptionValidator.Result}s from running | |
| * {@link CmdLineOptionValidator}s. | |
| */ | |
| public static List<CmdLineOptionValidator.Result> validate( | |
| CmdLineOptionInstance option) { | |
| Validate.notNull(option); | |
| List<CmdLineOptionValidator.Result> results = Lists.newArrayList(); | |
| if (option.isValidatable()) { | |
| for (CmdLineOptionValidator validator : ((ValidatableCmdLineOption) option | |
| .getOption()).getValidators()) { | |
| results.add(validator.validate(option)); | |
| } | |
| } | |
| if (option.isGroup()) { | |
| for (CmdLineOptionInstance subOption : option.getSubOptions()) { | |
| results.addAll(validate(subOption)); | |
| } | |
| } | |
| return results; | |
| } | |
| /** | |
| * Finds the {@link CmdLineOptionValidator.Result}s with grade of FAIL. | |
| * | |
| * @param results | |
| * The {@link CmdLineOptionValidator.Result}s which are checked if | |
| * they have a failing grade. | |
| * @return {@link CmdLineOptionValidator.Result}s with grade of FAIL. | |
| */ | |
| public static List<CmdLineOptionValidator.Result> determineFailedValidation( | |
| List<CmdLineOptionValidator.Result> results) { | |
| List<CmdLineOptionValidator.Result> failedResults = Lists.newArrayList(); | |
| for (CmdLineOptionValidator.Result result : results) { | |
| if (result.getGrade().equals(CmdLineOptionValidator.Result.Grade.FAIL)) { | |
| failedResults.add(result); | |
| } | |
| } | |
| return failedResults; | |
| } | |
| /** | |
| * Runs the {@link CmdLineOptionInstance}'s handler if it a perform and | |
| * quit option. | |
| * | |
| * @param option | |
| * The {@link CmdLineOptionInstance} whose handler will be run | |
| */ | |
| public static void handlePerformAndQuitOption(CmdLineOptionInstance option) { | |
| Validate.notNull(option); | |
| if (option.isHandleable() | |
| && ((HandleableCmdLineOption) option.getOption()).getHandler() != null) { | |
| ((HandleableCmdLineOption) option.getOption()).getHandler() | |
| .handleOption(null, option); | |
| } | |
| if (option.isGroup()) { | |
| for (CmdLineOptionInstance subOption : option.getSubOptions()) { | |
| handlePerformAndQuitOption(subOption); | |
| } | |
| } | |
| } | |
| /** | |
| * Runs the {@link CmdLineOptionInstance}'s handler against the given | |
| * {@link CmdLineAction}. | |
| * | |
| * @param action | |
| * The {@link CmdLineAction} which the given | |
| * {@link CmdLineOptionInstance}'s handler will be run against | |
| * @param option | |
| * The {@link CmdLineOptionInstance} whose handler will be run | |
| * against the given {@link CmdLineAction} | |
| */ | |
| public static void handle(CmdLineAction action, CmdLineOptionInstance option) { | |
| Validate.notNull(action); | |
| Validate.notNull(option); | |
| if (option.isHandleable() | |
| && ((HandleableCmdLineOption) option.getOption()).getHandler() != null) { | |
| ((HandleableCmdLineOption) option.getOption()).getHandler() | |
| .handleOption(action, option); | |
| } | |
| if (option.isGroup()) { | |
| for (CmdLineOptionInstance subOption : option.getSubOptions()) { | |
| handle(action, subOption); | |
| } | |
| } | |
| } | |
| /** | |
| * Formats given string to a string where txt starts at startIndex and wraps | |
| * around at endIndex, all other indexes are filled with empty space. | |
| */ | |
| public static String getFormattedString(String string, int startIndex, | |
| int endIndex) { | |
| StringBuffer outputString = new StringBuffer(""); | |
| String[] splitStrings = StringUtils.split(string, " "); | |
| StringBuffer curLine = null; | |
| for (int i = 0; i < splitStrings.length; i++) { | |
| curLine = new StringBuffer(""); | |
| curLine.append(splitStrings[i] + " "); | |
| for (; i + 1 < splitStrings.length | |
| && curLine.length() + splitStrings[i + 1].length() <= (endIndex - startIndex); i++) | |
| curLine.append(splitStrings[i + 1] + " "); | |
| outputString.append(StringUtils.repeat(" ", startIndex) | |
| + curLine.toString() + "\n"); | |
| } | |
| return outputString.toString(); | |
| } | |
| public static List<?> convertToType(List<String> values, Class<?> type) | |
| throws MalformedURLException, ClassNotFoundException, | |
| InstantiationException, IllegalAccessException { | |
| if (type.equals(File.class)) { | |
| List<Object> files = new LinkedList<Object>(); | |
| for (String value : values) | |
| files.add(new File(value)); | |
| return files; | |
| } else if (type.equals(Boolean.class) || type.equals(Boolean.TYPE)) { | |
| List<Object> booleans = new LinkedList<Object>(); | |
| for (String value : values) | |
| booleans.add(value.toLowerCase().trim().equals("true")); | |
| return booleans; | |
| } else if (type.equals(URL.class)) { | |
| List<Object> urls = new LinkedList<Object>(); | |
| for (String value : values) | |
| urls.add(new URL(value)); | |
| return urls; | |
| } else if (type.equals(Class.class)) { | |
| List<Object> classes = new LinkedList<Object>(); | |
| for (String value : values) | |
| classes.add(Class.forName(value)); | |
| return classes; | |
| } else if (type.equals(List.class)) { | |
| List<Object> lists = new LinkedList<Object>(); | |
| lists.add(values); | |
| return lists; | |
| } else if (type.equals(Integer.class) || type.equals(Integer.TYPE)) { | |
| List<Object> ints = new LinkedList<Object>(); | |
| for (String value : values) | |
| ints.add(new Integer(value)); | |
| return ints; | |
| } else if (type.equals(Long.class) || type.equals(Long.TYPE)) { | |
| List<Object> longs = new LinkedList<Object>(); | |
| for (String value : values) | |
| longs.add(new Long(value)); | |
| return longs; | |
| } else if (type.equals(Double.class) || type.equals(Double.TYPE)) { | |
| List<Object> doubles = new LinkedList<Object>(); | |
| for (String value : values) | |
| doubles.add(new Double(value)); | |
| return doubles; | |
| } else if (type.equals(String.class)) { | |
| StringBuffer combinedString = new StringBuffer(""); | |
| for (String value : values) | |
| combinedString.append(value + " "); | |
| return Lists.newArrayList(combinedString.toString().trim()); | |
| } else { | |
| List<Object> objects = new LinkedList<Object>(); | |
| for (String value : values) { | |
| Object object = Class.forName(value).newInstance(); | |
| if (!type.isAssignableFrom(object.getClass())) { | |
| throw new RuntimeException(object.getClass() + " is not a valid" | |
| + " type or sub-type of " + type); | |
| } | |
| objects.add(object); | |
| } | |
| return objects; | |
| } | |
| } | |
| } |