Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 Tatsuhiro Tsujikawa
   *
   * Permission is hereby granted, free of charge, to any person
   * obtaining a copy of this software and associated documentation
   * files (the "Software"), to deal in the Software without
   * restriction, including without limitation the rights to use, copy,
   * modify, merge, publish, distribute, sublicense, and/or sell copies
   * of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 package net.sourceforge.argparse4j.internal;
 
 import java.util.Map;
 
The application code must not use this class directly.
 
 public final class ArgumentImpl implements Argument {
 
     private String name_;
     private String flags_[];
     private String dest_;
     private ArgumentType<?> type_ = new StringArgumentType();
     private ArgumentAction action_ = Arguments.store();
     private ArgumentChoice choice_;
     private Object const_;
     private Object default_;
     private FeatureControl defaultControl_;
     private boolean required_;
     private String metavar_[];
     private int minNumArg_ = -1;
     private int maxNumArg_ = -1;
     private String help_ = "";
     private ArgumentGroup argumentGroup_;
 
     public ArgumentImpl(PrefixPattern prefixPatternString... nameOrFlags) {
         this(prefixPatternnullnameOrFlags);
     }
 
     public ArgumentImpl(PrefixPattern prefixPattern,
             ArgumentGroup argumentGroupString... nameOrFlags) {
         assert (nameOrFlags.length > 0);
          = argumentGroup;
         if (nameOrFlags.length == 1 && !prefixPattern.match(nameOrFlags[0])) {
              = nameOrFlags[0];
              = ;
         } else {
              = nameOrFlags;
             for (String flag : ) {
                 if (!prefixPattern.match(flag)) {
                     throw new IllegalArgumentException(
                             String.format(
                                     "invalid option string '%s': must start with a character '%s'",
                                     flagprefixPattern.getPrefixChars()));
                 }
             }
             for (String flag : ) {
                 boolean longflag = prefixPattern.matchLongFlag(flag);
                 if ( == null) {
                      = flag;
                     if (longflag) {
                         break;
                     }
                 } else if (longflag) {
                      = flag;
                     break;
                }
            }
             = prefixPattern.removePrefix().replace('-''_');
        }
    }
    @Override
    public String textualName() {
        if ( == null) {
            return TextHelper.concat(, 0, "/");
        } else {
            return ;
        }
    }

    
Short syntax is used in usage message, e.g. --foo BAR

Returns:
short syntax
    public String formatShortSyntax() {
        if ( == null) {
            StringBuilder sb = new StringBuilder();
            if (!) {
                sb.append("[");
            }
            sb.append([0]);
            String mv = formatMetavar();
            if (!mv.isEmpty()) {
                sb.append(" ").append(mv);
            }
            if (!) {
                sb.append("]");
            }
            return sb.toString();
        } else {
            return formatMetavar();
        }
    }
    public String[] resolveMetavar() {
        if ( == null) {
            String metavar[] = new String[1];
            if( == null) {
                metavar[0] = isOptionalArgument() ? 
                        .toUpperCase() : ;
            } else {
                metavar[0] = .textualFormat();
            }
            return metavar;
        } else {
            return ;
        }
    }
    public String formatMetavar() {
        StringBuffer sb = new StringBuffer();
        if (.consumeArgument()) {
            String metavar[] = resolveMetavar();
            if ( == 0 &&  == 1) {
                sb.append("[").append(metavar[0]).append("]");
            } else if ( == 0 &&  == .) {
                sb.append("[").append(metavar[0]).append(" [")
                        .append(metavar.length == 1 ? metavar[0] : metavar[1])
                        .append(" ...]]");
            } else if ( == 1 &&  == .) {
                sb.append(metavar[0]).append(" [")
                        .append(metavar.length == 1 ? metavar[0] : metavar[1])
                        .append(" ...]");
            } else if ( == -1) {
                sb.append(metavar[0]);
            } else if ( > 0 &&  == ) {
                int imax;
                for (i = 0, max = Math.min(metavar.length); i < max; ++i) {
                    sb.append(metavar[i]).append(" ");
                }
                for (; i < ; ++i) {
                    sb.append(metavar[metavar.length - 1]).append(" ");
                }
                sb.delete(sb.length() - 1, sb.length());
            }
        }
        return sb.toString();
    }
    private String formatHelpTitle() {
        if (isOptionalArgument()) {
            String mv = formatMetavar();
            StringBuffer sb = new StringBuffer();
            sb.setLength(0);
            for (String flag : ) {
                sb.append(flag);
                if (!mv.isEmpty()) {
                    sb.append(" ").append(mv);
                }
                sb.append(", ");
            }
            if (sb.length() > 2) {
                sb.delete(sb.length() - 2, sb.length());
            }
            return sb.toString();
        } else {
            return resolveMetavar()[0];
        }
    }
    public void printHelp(PrintWriter writerboolean defaultHelp,
            TextWidthCounter textWidthCounterint width) {
        String help;
        if (defaultHelp &&  != null) {
            StringBuilder sb = new StringBuilder();
            if (!.isEmpty()) {
                sb.append(" ");
            }
            sb.append(String.format("(default: %s)".toString()));
            help = sb.toString();
        } else {
            help = ;
        }
        TextHelper.printHelp(writerformatHelpTitle(), helptextWidthCounter,
                width);
    }
    public Object convert(ArgumentParserImpl parserString value)
            throws ArgumentParserException {
        Object obj = .convert(parserthisvalue);
        if ( != null && !.contains(obj)) {
            throw new ArgumentParserException(String.format(
                    "invalid choice: '%s' (choose from %s)"value,
                    .textualFormat()), parserthis);
        }
        return obj;
    }
    @Override
    public ArgumentImpl nargs(int n) {
        if (n <= 0) {
            throw new IllegalArgumentException("nargs must be positive integer");
        }
         =  = n;
        return this;
    }
    @Override
    public ArgumentImpl nargs(String n) {
        if (n.equals("*")) {
             = 0;
             = .;
        } else if (n.equals("+")) {
             = 1;
             = .;
        } else if (n.equals("?")) {
             = 0;
             = 1;
        } else {
            throw new IllegalArgumentException(
                    "narg expects positive integer or one of '*', '+' or '?'");
        }
        return this;
    }
    @Override
    public ArgumentImpl setConst(Object value) {
        // Allow null
         = value;
        return this;
    }
    @Override
    public <E> ArgumentImpl setConst(E... values) {
        // Allow null
         = Arrays.asList(values);
        return this;
    }
    @Override
    public ArgumentImpl setDefault(Object value) {
        // Allow null
         = value;
        return this;
    }
    @Override
    public <E> ArgumentImpl setDefault(E... values) {
        // Allow null
         = Arrays.asList(values);
        return this;
    }
    @Override
    public ArgumentImpl setDefault(FeatureControl ctrl) {
         = ctrl;
        return this;
    }
    @Override
    public <T> ArgumentImpl type(Class<T> type) {
        if (type == null) {
            throw new IllegalArgumentException("type cannot be null");
        }
         = new ConstructorArgumentType<T>(type);
        return this;
    }
    @Override
    public <T> ArgumentImpl type(ArgumentType<T> type) {
        if (type == null) {
            throw new IllegalArgumentException("type cannot be null");
        }
         = type;
        return this;
    }
    @Override
    public ArgumentImpl required(boolean required) {
         = required;
        return this;
    }
    @Override
    public ArgumentImpl action(ArgumentAction action) {
        if (action == null) {
            throw new IllegalArgumentException("action cannot be null");
        }
         = action;
        .onAttach(this);
        return this;
    }
    @Override
    public ArgumentImpl choices(ArgumentChoice choice) {
        if (choice == null) {
            throw new IllegalArgumentException("choice cannot be null");
        }
         = choice;
        return this;
    }
    @Override
    public <E> ArgumentImpl choices(Collection<E> values) {
        if (values == null) {
            throw new IllegalArgumentException("choice cannot be null");
        }
         = new CollectionArgumentChoice<E>(values);
        return this;
    }
    @Override
    public <E> ArgumentImpl choices(E... values) {
        if (values == null) {
            throw new IllegalArgumentException("choice cannot be null");
        }
         = new CollectionArgumentChoice<E>(values);
        return this;
    }
    @Override
    public ArgumentImpl dest(String dest) {
        if (dest == null) {
            throw new IllegalArgumentException("dest cannot be null");
        }
         = dest;
        return this;
    }
    @Override
    public ArgumentImpl metavar(String... metavar) {
        if (metavar.length == 0) {
            throw new IllegalArgumentException("No metavar specified");
        }
        for (String m : metavar) {
            if (m == null) {
                throw new IllegalArgumentException("metavar cannot be null");
            }
        }
         = metavar;
        return this;
    }
    @Override
    public ArgumentImpl help(String help) {
         = TextHelper.nonNull(help);
        return this;
    }
    public boolean isOptionalArgument() {
        return  == null;
    }
    public void run(ArgumentParserImpl parserMap<StringObjectres,
            String flagObject valuethrows ArgumentParserException {
        .run(parserthisresflagvalue);
    }
    // Getter methods
    @Override
    public String getDest() {
        return ;
    }
    @Override
    public Object getConst() {
        return ;
    }
    @Override
    public Object getDefault() {
        if ( == null &&  > 1) {
            return new ArrayList<Object>();
        } else {
            return ;
        }
    }
    @Override
    public FeatureControl getDefaultControl() {
        return ;
    }
    public String getName() {
        return ;
    }
    public boolean isRequired() {
        return ;
    }
    public int getMinNumArg() {
        return ;
    }
    public int getMaxNumArg() {
        return ;
    }
    public String[] getMetavar() {
        return ;
    }
    public ArgumentGroup getArgumentGroup() {
        return ;
    }
    public ArgumentAction getAction() {
        return ;
    }
    public String getHelp() {
        return ;
    }
    public String[] getFlags() {
        return ;
    }
New to GrepCode? Check out our FAQ X