Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package bpiwowar.argparser.handlers;
  
  
  import java.util.Arrays;
A handler that calls a callable with callable arguments extracted from command line

Author(s):
B. Piwowarski
 
 public class CallableHandler extends Handler {
 	final static private Logger logger = Logger
 
 	private final Object object;
 	private final Handlers.Callable callable;
 	private final Handler[] handlers;
 	private final ObjectHolder<?>[] holders;
 
 	private Pattern regexp;
     private final Field field;
 
     public CallableHandler(Object objectField fieldHandlers.Callable methodHandler[] handlers,
                            ObjectHolder<?>[] holdersString regexp) {
 		this. = object;
 		this. = method;
 		this. = handlers;
 		this. = holders;
         this. = field;
 		this. = regexp != null ? Pattern.compile(regexp) : null;
 	}
 
 	public int parse(ArgParser argParserString[] argsint idx)
 			throws ArgParserException {
 		Object[] objects = new Object[.];
 
 		// --- Use the regular expression if one was given
 		if ( != null) {
 			Matcher matcher = .matcher(args[idx]);
 			if (!matcher.matches() || matcher.start() != 0
 					|| matcher.end() != args[idx].length())
 				throw new IllegalArgumentValue(
 						"%s does not match regular expression %s"args[idx],
 
 			String[] args2 = new String[matcher.groupCount()];
 			.debug("Found " + matcher.groupCount() + " groups in "
 					+ args[idx] + " with " + );
 			for (int i = 0; i < args2.lengthi++) {
 				args2[i] = matcher.group(i + 1);
 				if (args2[i] == null)
 					args2[i] = "";
 			}
 
 			.debug("Arguments are " + Arrays.toString(args2));
 			int idx2 = 0;
 			for (int i = 0; i < .i++) {
 				.debug(String.format("Processing arguments with %s",
 						[i]));
 				idx2 = [i].parse(argParserargs2idx2);
 				objects[i] = [i].;
 				.debug(String.format("Result is %s"objects[i]));
 			}
 
 			if (idx2 != args2.length)
 				.warn("Some arguments were not read while processing argument with regular expression");
 
 			idx++;
 		} else
 			for (int i = 0; i < .i++) {
 				.debug(String.format("Processing arguments with %s",
 						[i]));
 				idx = [i].parse(argParserargsidx);
 				objects[i] = [i].;
 				.debug(String.format("Result is %s"objects[i]));
 
 			}
 
 		// Call the callable
 		try {
 			boolean accessible = .isAccessible();
 			if (!accessible)
 			.debug(String.format("Calling the callable %s of object %s",
                     ));
             if ( instanceof Handlers.CallableMethod) {
                 ((Handlers.CallableMethod).invoke(objects);
             }
             else if ( instanceof Handlers.CallableConstructor) {
                 final Object o = ((Handlers.CallableConstructor).newInstance(objects);
                 Fields.set(o);
            }
            else throw new AssertionError("Should not happen: we can handle only methods or constructors");
            if (!accessible)
catch (RuntimeException e) {
			throw e;
catch (Throwable e) {
			throw new ArgParseException(e,
					"Error (%s) while invoking callable %s of object %s"e,
                    );
		}
		return idx;
	}
New to GrepCode? Check out our FAQ X