public Options() 
{
              
        // nothing to do
}

Construct a new Options descriptor

 public Options addOption(Option opt) 
{
        String key = opt.getKey();
        // add it to the long option list
        if (opt.hasLongOpt())
        {
            longOpts.put(opt.getLongOpt(), opt);
        }
        // if the option is required add it to the required list
        if (opt.isRequired() ) 
        {
            if( requiredOpts.contains(key) ) {
                requiredOpts.remove( requiredOpts.indexOf(key) );
            }
            requiredOpts.add(key);
        }
        shortOpts.put(key, opt);
        return this;
}

Adds an option instance

 public Options addOption(String opt,
    boolean hasArg,
    String description) 
{
        addOption(opt, null, hasArg, description);
        return this;
}

Add an option that only contains a short-name. It may be specified as requiring an argument.

 public Options addOption(String opt,
    String longOpt,
    boolean hasArg,
    String description) 
{
        addOption(new Option(opt, longOpt, hasArg, description));
        return this;
}

Add an option that contains a short-name and a long-name. It may be specified as requiring an argument.

 public Options addOptionGroup(OptionGroup group) 
{
        Iterator options = group.getOptions().iterator();
        if (group.isRequired())
        {
            requiredOpts.add(group);
        }
        while (options.hasNext())
        {
            Option option = (Option) options.next();
            // an Option cannot be required if it is in an
            // OptionGroup, either the group is required or
            // nothing is required
            option.setRequired(false);
            addOption(option);
            optionGroups.put(option.getKey(), group);
        }
        return this;
}

Add the specified option group.

 public Option getOption(String opt) 
{
        opt = Util.stripLeadingHyphens(opt);
        if (shortOpts.containsKey(opt))
        {
            return (Option) shortOpts.get(opt);
        }
        return (Option) longOpts.get(opt);
}

Retrieve the named Option

 public OptionGroup getOptionGroup(Option opt) 
{
        return (OptionGroup) optionGroups.get(opt.getKey());
}

Returns the OptionGroup the opt belongs to.

 Collection getOptionGroups() 
{
    	return new HashSet(optionGroups.values());
}

Lists the OptionGroups that are members of this Options instance.

 public Collection getOptions() 
{
        return Collections.unmodifiableCollection(helpOptions());
}

Retrieve a read-only list of options in this set

 public List getRequiredOptions() 
{
        return requiredOpts;
}

Returns the required options as a java.util.Collection.

 public boolean hasOption(String opt) 
{
        opt = Util.stripLeadingHyphens(opt);
        return shortOpts.containsKey(opt) || longOpts.containsKey(opt);
}

Returns whether the named Option is a member of this Options .

 List helpOptions() 
{
        List opts = new ArrayList(shortOpts.values());
        // now look through the long opts to see if there are any Long-opt
        // only options
        Iterator iter = longOpts.values().iterator();
        while (iter.hasNext())
        {
            Object item = iter.next();
            if (!opts.contains(item))
            {
                opts.add(item);
            }
        }
        return new ArrayList(opts);
}

Returns the Options for use by the HelpFormatter.

 public String toString() 
{
        StringBuffer buf = new StringBuffer();
        buf.append("[ Options: [ short ");
        buf.append(shortOpts.toString());
        buf.append(" ] [ long ");
        buf.append(longOpts);
        buf.append(" ]");
        return buf.toString();
}

Dump state, suitable for debugging.