Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.cli;
 
 
 import java.util.*;

A command line parser defined by option, value and child annotations taken from the defining class used to create the parser. The resulting syntax is line = option* child | option* value1 ... valueN value0* Running the parser configures an instance of the defining class. It takes a command line and an instance of the defining class, options and values perform side effects, children create sub-instances.
 
 public class Parser {
     public static Parser create(Schema metadataClass<?> cl) {
         Parser parser;
         Option option;
         Value value;
         Remaining remaining;
         Child child;
         
         parser = new Parser(metadata);
         for (Method m : cl.getMethods()) {
             option = m.getAnnotation(Option.class);
             if (option != null) {
                 parser.addOption(option.value(), ArgumentMethod.create(option.value(), metadatam));
             }
             value = m.getAnnotation(Value.class);
             if (value != null) {
                 parser.addValue(value.position(), ArgumentMethod.create(value.name(), metadatam));
             }
             remaining = m.getAnnotation(Remaining.class);
             if (remaining != null) {
                 parser.addValue(0, ArgumentMethod.create(remaining.name(), metadatam));
             }
             child = m.getAnnotation(Child.class);
             if (child != null) {
                 parser.addChild(new ChildMethod(child.value(), m));
             }
         }
         while (!Object.class.equals(cl)) {
             for (Field fcl.getDeclaredFields()) {
                 option = f.getAnnotation(Option.class);
                 if (option != null) {
                     parser.addOption(option.value(), ArgumentField.create(option.value(), metadataf));
                 }
                 value = f.getAnnotation(Value.class);
                 if (value != null) {
                     parser.addValue(value.position(), ArgumentField.create(value.name(), metadataf));
                 }
                 remaining = f.getAnnotation(Remaining.class);
                 if (remaining != null) {
                     parser.addValue(0, ArgumentField.create(remaining.name(), metadataf));
                 }
             }
             cl = cl.getSuperclass();
         }
         return parser;
     }
 
     //--
     
     private final Schema metadata;
     private final Map<StringArgumentoptions;
     private final List<Argumentvalues// and remaining at index 0
     private final Map<StringChildMethodchildren;
     
     public Parser(Schema metadata) {
         this. = metadata;
         this. = new HashMap<StringArgument>();
         this. = new ArrayList<Argument>();
         .add(null);
         this. = new HashMap<StringChildMethod>();
     }
    public void addOption(String nameArgument arg) {
        if (.put(namearg) != null) {
            throw new IllegalArgumentException("duplicate option: " + name);
        }
    }
    
    public void addValue(int positionArgument arg) {
        while (position >= .size()) {
            .add(null);
        }
        if (.get(position) != null) {
            throw new IllegalArgumentException("duplicate argument for position " + position);
        }
        .set(positionarg);
    }
    public void addChild(ChildMethod factory) {
        if (.put(factory.getName(), factory) != null) {
            throw new IllegalArgumentException("duplicate child command " + factory.getName());
        }
    }
    
    private static boolean isBoolean(Argument arg) {
        return arg.getType().getType().equals(Boolean.class);
    }
    public void checkValues() {
        int i;
        int max;
        
        max = .size();
        for (i = 0; i < maxi++) {
            if (.get(i) == null) {
                throw new IllegalStateException("missing value " + i);
            }
        }
    }
    //--
    
    
convenience methode
    public Object run(Object targetString... args) {
        return run(target, 0, Arrays.asList(args));
    }

    

Returns:
target object or child object
    public Object run(Object targetint startList<Stringargs) {
        int imax;
        String arg;
        Argument argument;
        String value;
        
        max = args.size();
        for (i = starti < maxi++) {
            arg = args.get(i);
            if (arg.length() > 1 && arg.startsWith("-")) {
                argument = .get(arg.substring(1));
                if (argument == null) {
                    throw new ArgumentException("unknown option " + arg);
                }
                if (isBoolean(argument)) {
                    value = "true";
                } else {
                    if (i + 1 >= max) {
                        throw new ArgumentException("missing value for option " + arg);
                    }
                    i++;
                    value = args.get(i);
                }
                set(argumenttargetvalue);
            } else {
                break;
            }
        }
        if (.size() > 0 && i < max) {
            ChildMethod child = lookupChild(args.get(i));
            if (child != null) {
                // dispatch to child command
                target = child.invoke(target);
                return Parser.create(target.getClass()).run(targeti + 1, args);
            }
        }
        // don't dispatch, target remains unchanged
        for (int position = 1; position < .size(); position++, i++) {
            if (i >= max) {
                throw new ArgumentException("missing argument '" + .get(position).getName() + "'");
            }
            set(.get(position), targetargs.get(i));
        }
        if (.get(0) != null) {
            for ( ; i < maxi++) {
                set(.get(0), targetargs.get(i));
            }
        }
        if (i != max) {
            if (.size() > 0 && .size() == 1 && .get(0) == null) {
                throw new ArgumentException("unknown command, expected on of " + .keySet());
            } else {
                StringBuilder builder;
                
                builder = new StringBuilder("unknown value(s):");
                for ( ; i < maxi++) {
                    builder.append(' ');
                    builder.append(args.get(i));
                }
                throw new ArgumentException(builder.toString());
            }
        }
        return target;
    }
    public ChildMethod lookupChild(String name) {
        return .get(name);
    }
    
    //--
    
    public void set(Argument argObject objString value) {
        Object converted;
        
        try {
            converted = run(arg.getType(), value);
        } catch (ArgumentException e) {
            throw new ArgumentException("invalid argument " + arg.getName() + ": " + e.getMessage());
        }
        arg.set(objconverted);
    }
    
    public Object run(SimpleType simpleString arg) {
        try {
            return simple.stringToValue(arg);
        } catch (SimpleTypeException e) {
            throw new ArgumentException(e.getMessage(), e);
        }
    }
New to GrepCode? Check out our FAQ X