public ObjectStream<POSSample> create(String[] args) { ParseSampleStreamFactory.Parameters params = ArgumentParser.parse(args, ParseSampleStreamFactory.Parameters.class); ObjectStream<Parse> parseSampleStream = StreamFactoryRegistry.getFactory(Parse.class, StreamFactoryRegistry.DEFAULT_FORMAT).create( ArgumentParser.filter(args, ParseSampleStreamFactory.Parameters.class)); return new ParseToPOSSampleStream(parseSampleStream); }
/** * Creates a usage string which can be printed in case the user did specify the arguments * incorrectly. Incorrectly is defined as {@link ArgumentParser#validateArguments(String[], Class)} * returns false. * * @param argProxyInterface interface with parameter descriptions * @return the help message usage string */ @SuppressWarnings({"unchecked"}) public static <T> String createUsage(Class<T> argProxyInterface) { return createUsage(new Class[]{argProxyInterface}); }
@Test(expected = IllegalArgumentException.class) public void testAllOptionalArgumentsExtraArgument() { String argsString = "-encoding UTF-8"; Assert.assertFalse(ArgumentParser.validateArguments(argsString.split(" "), AllOptionalArguments.class)); ArgumentParser.parse(argsString.split(" "), AllOptionalArguments.class); }
protected <T> T validateAndParseParams(String[] args, Class<T> argProxyInterface) { String errorMessage = ArgumentParser.validateArgumentsLoudly(args, argProxyInterface); if (null != errorMessage) { throw new TerminateToolException(1, errorMessage + "\n" + getHelp()); } return ArgumentParser.parse(args, argProxyInterface); }
/** * Validates arguments for a format processed by the <code>factory</code>. * @param factory a stream factory * @param args arguments */ protected void validateFactoryArgs(ObjectStreamFactory<T> factory, String[] args) { String errMessage = ArgumentParser.validateArgumentsLoudly(args, factory.getParameters()); if (null != errMessage) { throw new TerminateToolException(1, "Format parameters are invalid: " + errMessage + "\n" + "Usage: " + ArgumentParser.createUsage(factory.getParameters())); } }
public ObjectStream<NameSample> create(String[] args) { Parameters params = ArgumentParser.parse(args, Parameters.class); TokenizerModel tokenizerModel = new TokenizerModelLoader().load(params.getTokenizerModel()); Tokenizer tokenizer = new TokenizerME(tokenizerModel); ObjectStream<String> mucDocStream = new FileToStringSampleStream( new DirectorySampleStream(params.getData(), file -> StringUtil.toLowerCase(file.getName()).endsWith(".sgm"), false), StandardCharsets.UTF_8); return new MucNameSampleStream(tokenizer, mucDocStream); }
@Override public void run(String[] args) { String errMessage = ArgumentParser.validateArgumentsLoudly(args, this.paramsClass); if (null != errMessage) { throw new TerminateToolException(1, errMessage + "\n" + getHelp()); .getOrCreate(); params = (PredictTrainingToolParams) ArgumentParser.parse( ArgumentParser.filter(args, this.paramsClass), this.paramsClass);
public static <T> T parse(String[] args, Class<T> argProxyInterface) { checkProxyInterfaces(argProxyInterface); if (!validateArguments(args, argProxyInterface)) throw new IllegalArgumentException("Passed args must be valid!"); String parameterName = methodNameToParameter(method.getName()); String valueString = CmdLineUtil.getParameter(parameterName, args);
/** * Tests if the argument are correct or incorrect. Incorrect means, that mandatory arguments are missing or * there are unknown arguments. The argument value itself can also be incorrect, but this * is checked by the {@link ArgumentParser#parse(String[], Class)} method and reported accordingly. * * @param args command line arguments * @param argProxyInterfaces interfaces with parameters description * @return true, if arguments are valid */ public static boolean validateArguments(String[] args, Class<?>... argProxyInterfaces) { return null == validateArgumentsLoudly(args, argProxyInterfaces); }
checkProxyInterfaces(argProxyInterfaces); String paramName = methodNameToParameter(method.getName());
/** * Tests if the argument are correct or incorrect. Incorrect means, that mandatory arguments are missing or * there are unknown arguments. The argument value itself can also be incorrect, but this * is checked by the {@link ArgumentParser#parse(String[], Class)} method and reported accordingly. * * @param args command line arguments * @param argProxyInterface interface with parameters description * @return true, if arguments are valid */ @SuppressWarnings({"unchecked"}) public static <T> boolean validateArguments(String[] args, Class<T> argProxyInterface) { return validateArguments(args, new Class[]{argProxyInterface}); }
public final void run(String format, String[] args) { ModelUpdaterParams params = validateAndParseParams( ArgumentParser.filter(args, ModelUpdaterParams.class), ModelUpdaterParams.class); String[] fargs = ArgumentParser.filter(args, factory.getParameters()); validateFactoryArgs(factory, fargs); ObjectStream<Parse> sampleStream = factory.create(fargs);
private static void appendHelpForTool(TypedCmdLineTool<?> tool, StringBuilder sb) { Class<?> type = tool.type; Set<String> formats = StreamFactoryRegistry.getFactories(type).keySet(); sb.append("<para>The supported formats and arguments are:</para>\n\n"); Map<String, List<Argument>> formatArguments = new LinkedHashMap<>(); for (String formatName : formats) { if (!StreamFactoryRegistry.DEFAULT_FORMAT.equals(formatName)) { ObjectStreamFactory<?> format = tool.getStreamFactory(formatName); formatArguments.put(formatName, ArgumentParser.createArguments(format.getParameters())); } } appendArgumentTable(formatArguments, sb); }
public ObjectStream<TokenSample> create(String[] args) { Parameters params = ArgumentParser.parse(args, Parameters.class); CmdLineUtil.checkInputFile("Data", params.getData()); IrishSentenceBankDocument isbDoc = null; try { isbDoc = IrishSentenceBankDocument.parse(params.getData()); } catch (IOException ex) { CmdLineUtil.handleCreateObjectStreamError(ex); } return new IrishSentenceBankTokenSampleStream(isbDoc); } }
System.arraycopy(args, 1, formatArgs, 0, formatArgs.length); String helpString = createHelpString(format, ArgumentParser.createUsage(streamFactory.getParameters())); if (0 == formatArgs.length || (1 == formatArgs.length && "help".equals(formatArgs[0]))) { System.out.println(helpString); String errorMessage = ArgumentParser.validateArgumentsLoudly(formatArgs, streamFactory.getParameters()); if (null != errorMessage) { throw new TerminateToolException(1, errorMessage + "\n" + helpString);
protected <T> T validateAndParseParams(String[] args, Class<T> argProxyInterface) { String errorMessage = ArgumentParser.validateArgumentsLoudly(args, argProxyInterface); if (null != errorMessage) { throw new TerminateToolException(1, errorMessage + "\n" + getHelp()); } return ArgumentParser.parse(args, argProxyInterface); }
public static <T> T parse(String[] args, Class<T> argProxyInterface) { checkProxyInterfaces(argProxyInterface); if (!validateArguments(args, argProxyInterface)) throw new IllegalArgumentException("Passed args must be valid!"); String parameterName = methodNameToParameter(method.getName()); String valueString = CmdLineUtil.getParameter(parameterName, args);
/** * Tests if the arguments are correct or incorrect. * * @param args command line arguments * @param argProxyInterface interface with parameters description * @return null, if arguments are valid or error message otherwise */ public static String validateArgumentsLoudly(String[] args, Class<?> argProxyInterface) { return validateArgumentsLoudly(args, new Class[]{argProxyInterface}); }
checkProxyInterfaces(argProxyInterfaces); String paramName = methodNameToParameter(method.getName());
/** * Tests if the argument are correct or incorrect. Incorrect means, that mandatory arguments are missing or * there are unknown arguments. The argument value itself can also be incorrect, but this * is checked by the {@link ArgumentParser#parse(String[], Class)} method and reported accordingly. * * @param args command line arguments * @param argProxyInterface interface with parameters description * @return true, if arguments are valid */ @SuppressWarnings({"unchecked"}) public static <T> boolean validateArguments(String[] args, Class<T> argProxyInterface) { return validateArguments(args, new Class[]{argProxyInterface}); }