| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. 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.jackrabbit.command.cli; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.ResourceBundle; |
| import java.util.TreeMap; |
| |
| import org.apache.commons.collections.CollectionUtils; |
| import org.apache.commons.collections.Predicate; |
| import org.apache.commons.collections.iterators.IteratorChain; |
| import org.apache.jackrabbit.command.CommandHelper; |
| |
| /** |
| * Command Line |
| */ |
| public class CommandLine implements Comparable, Cloneable { |
| /** Resource bundle */ |
| protected static ResourceBundle bundle = CommandHelper.getBundle(); |
| |
| /** Name */ |
| private String name; |
| |
| /** Description */ |
| private String description; |
| |
| /** Commons chain command implementation */ |
| private String impl; |
| |
| /** alias */ |
| private Collection alias = new ArrayList(); |
| |
| /** Options */ |
| private Map options = new TreeMap(); |
| |
| /** flags */ |
| private Map flags = new TreeMap(); |
| |
| /** arguments */ |
| private Map arguments = new TreeMap(); |
| |
| /** |
| * constructor |
| */ |
| public CommandLine() { |
| super(); |
| } |
| |
| /** |
| * @return required arguments |
| */ |
| public Collection getRequiredArguments() { |
| Predicate p = new Predicate() { |
| public boolean evaluate(Object o) { |
| Argument arg = (Argument) o; |
| return arg.isRequired(); |
| } |
| }; |
| return CollectionUtils.select(this.arguments.values(), p); |
| } |
| |
| /** |
| * @return required options |
| */ |
| public Collection getRequiredOptions() { |
| Predicate p = new Predicate() { |
| public boolean evaluate(Object o) { |
| Option opt = (Option) o; |
| return opt.isRequired(); |
| } |
| }; |
| return CollectionUtils.select(this.options.values(), p); |
| } |
| |
| /** |
| * @return the description. |
| */ |
| public String getDescription() { |
| return description; |
| } |
| |
| /** |
| * @return the localized description. |
| */ |
| public String getLocalizedDescription() { |
| if (description == null) { |
| return bundle.getString("cmd." + this.name); |
| } else { |
| return bundle.getString(this.description); |
| } |
| } |
| |
| /** |
| * @param description |
| * The description to set |
| */ |
| public void setDescription(String description) { |
| this.description = description; |
| } |
| |
| /** |
| * @return the flags |
| */ |
| public Map getFlags() { |
| return flags; |
| } |
| |
| /** |
| * @param flags |
| * The flags to set |
| */ |
| public void setFlags(Map flags) { |
| this.flags = flags; |
| } |
| |
| /** |
| * @return the impl |
| */ |
| public String getImpl() { |
| return impl; |
| } |
| |
| /** |
| * @param impl |
| * The impl to set |
| */ |
| public void setImpl(String impl) { |
| this.impl = impl; |
| } |
| |
| /** |
| * @return the name |
| */ |
| public String getName() { |
| return name; |
| } |
| |
| /** |
| * @param name |
| * the name to set |
| */ |
| public void setName(String name) { |
| this.name = name; |
| } |
| |
| /** |
| * @return the options |
| */ |
| public Map getOptions() { |
| return options; |
| } |
| |
| /** |
| * @param options |
| * the <code>Option</code>s to set |
| */ |
| public void setOptions(Map options) { |
| this.options = options; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public int compareTo(Object o) { |
| CommandLine cl = (CommandLine) o; |
| return name.compareTo(cl.name); |
| } |
| |
| /** |
| * @return all the parameters. i.e. args, options and flags. |
| */ |
| public Iterator getAllParameters() { |
| IteratorChain chain = new IteratorChain(); |
| chain.addIterator(getArguments().values().iterator()); |
| chain.addIterator(getOptions().values().iterator()); |
| chain.addIterator(getFlags().values().iterator()); |
| return chain; |
| } |
| |
| /** |
| * @return the required parameters. i.e. args, options and flags. |
| */ |
| public Iterator getRequiredParameters() { |
| IteratorChain chain = new IteratorChain(); |
| chain.addIterator(getRequiredArguments().iterator()); |
| chain.addIterator(getRequiredOptions().iterator()); |
| return chain; |
| } |
| |
| /** |
| * @param arg |
| * the <code>Argument</code> to add |
| */ |
| public void addArgument(Argument arg) { |
| if (arguments.containsKey(new Integer(arg.getPosition()))) { |
| throw new IllegalArgumentException( |
| "there's an argument in the position in command " + this.name); |
| } |
| // Put default values description and arg name i18n keys |
| if (arg.getArgName() == null) { |
| arg.setArgName("cmd." + this.getName() + "." + arg.getName()); |
| } |
| if (arg.getDescription() == null) { |
| arg.setDescription("cmd." + this.getName() + "." + arg.getName() |
| + ".desc"); |
| } |
| this.arguments.put(new Integer(arg.getPosition()), arg); |
| } |
| |
| /** |
| * @param opt the <code>Option</code> to add |
| */ |
| public void addOption(Option opt) { |
| // Put default values description and arg name i18n keys |
| if (opt.getArgName() == null) { |
| opt.setArgName("cmd." + this.getName() + "." + opt.getName()); |
| } |
| if (opt.getDescription() == null) { |
| opt.setDescription("cmd." + this.getName() + "." + opt.getName() |
| + ".desc"); |
| } |
| this.options.put(opt.getName(), opt); |
| } |
| |
| /** |
| * @param flag the <code>Flag</code> to add |
| */ |
| public void addFlag(Flag flag) { |
| // Put default values description and arg name i18n keys |
| if (flag.getDescription() == null) { |
| flag.setDescription("cmd." + this.getName() + "." + flag.getName() |
| + ".desc"); |
| } |
| this.flags.put(flag.getName(), flag); |
| } |
| |
| /** |
| * @return the arguments |
| */ |
| public Map getArguments() { |
| return arguments; |
| } |
| |
| /** |
| * @param arguments |
| * the arguments to set |
| */ |
| public void setArguments(Map arguments) { |
| this.arguments = arguments; |
| } |
| |
| /** |
| * @return the alias |
| */ |
| public Collection getAlias() { |
| return alias; |
| } |
| |
| /** |
| * @param alias |
| * the alias to set |
| */ |
| public void setAlias(Collection alias) { |
| this.alias = alias; |
| } |
| |
| /** |
| * @param alias the alias to add |
| */ |
| public void addAlias(String alias) { |
| this.alias.add(alias); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public Object clone() { |
| CommandLine cl = new CommandLine(); |
| cl.alias = this.alias; |
| // Arguments |
| Iterator iter = this.arguments.values().iterator(); |
| while (iter.hasNext()) { |
| Argument arg = (Argument) iter.next(); |
| cl.addArgument((Argument) arg.clone()); |
| } |
| cl.description = this.description; |
| // Flags |
| iter = this.flags.values().iterator(); |
| while (iter.hasNext()) { |
| Flag f = (Flag) iter.next(); |
| cl.addFlag((Flag) f.clone()); |
| } |
| cl.impl = this.impl; |
| cl.name = this.name; |
| // Flags |
| iter = this.options.values().iterator(); |
| while (iter.hasNext()) { |
| Option o = (Option) iter.next(); |
| cl.addOption((Option) o.clone()); |
| } |
| return cl; |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public String toString() { |
| return "CommandLine-" + this.getName() + "(" + impl + ")"; |
| } |
| } |