public boolean version() { return args.getBoolean( VERSION_ARG, false ); } }
private static boolean isVerbose( Args arguments ) { return arguments.getBoolean( VERBOSE, false, true ); }
/** * Like calling {@link #getBoolean(String, Boolean, Boolean)} with {@code true} for * {@code defaultValueIfNoValue}, i.e. specifying {@code --myarg} will interpret it as {@code true}. * * @param key argument key. * @param defaultValueIfNotSpecified used if argument not specified. * @return argument boolean value depending on what was specified, see above. */ @Deprecated public Boolean getBoolean( String key, Boolean defaultValueIfNotSpecified ) { return getBoolean( key, defaultValueIfNotSpecified, Boolean.TRUE ); }
@Override public String parse( Args parsedArgs ) { return Boolean.toString( parsedArgs.getBoolean( name, Boolean.parseBoolean( defaultValue ) ) ); } }
/** * Like calling {@link #getBoolean(String, Boolean)} with {@code false} for default value. * This is the most common case, i.e. returns {@code true} if boolean argument was specified as: * <ul> * <li>--myboolean</li> * <li>--myboolean=true</li> * </ul> * Otherwise {@code false. * } * @param key argument key. * @return {@code true} if argument was specified w/o value, or w/ value {@code true}, otherwise {@code false}. */ @Deprecated public boolean getBoolean( String key ) { return getBoolean( key, false ); }
@Test void testBooleanWithDefault() { // Given Args args = Args.parse( "--no_value" ); // When & then assertThat( args.getBoolean( "not_set", true, true ), equalTo( true ) ); assertThat( args.getBoolean( "not_set", false, true ), equalTo( false ) ); assertThat( args.getBoolean( "not_set", false, false ), equalTo( false ) ); assertThat( args.getBoolean( "not_set", true, false ), equalTo( true ) ); assertThat( args.getBoolean( "no_value", true, true ), equalTo( true ) ); assertThat( args.getBoolean( "no_value", false, true ), equalTo( true ) ); assertThat( args.getBoolean( "no_value", false, false ), equalTo( false ) ); assertThat( args.getBoolean( "no_value", true, false ), equalTo( false ) ); }
CsvImporter( Args args, Config databaseConfig, OutsideWorld outsideWorld ) throws IncorrectUsage { this.args = args; this.outsideWorld = outsideWorld; nodesFiles = extractInputFiles( args, "nodes", outsideWorld.errorStream() ); relationshipsFiles = extractInputFiles( args, "relationships", outsideWorld.errorStream() ); reportFileName = args.interpretOption( "report-file", withDefault( ImportCommand.DEFAULT_REPORT_FILE_NAME ), s -> s ); ignoreExtraColumns = args.getBoolean( "ignore-extra-columns", false ); ignoreDuplicateNodes = args.getBoolean( "ignore-duplicate-nodes", false ); ignoreBadRelationships = args.getBoolean( "ignore-missing-nodes", false ); try { validateInputFiles( nodesFiles, relationshipsFiles ); } catch ( IllegalArgumentException e ) { throw new IncorrectUsage( e.getMessage() ); } idType = args.interpretOption( "id-type", withDefault( IdType.STRING ), from -> IdType.valueOf( from.toUpperCase() ) ); inputEncoding = Charset.forName( args.get( "input-encoding", defaultCharset().name() ) ); highIO = args.getBoolean( "high-io", null, true ); // intentionally left as null if not specified this.databaseConfig = databaseConfig; }
TxFilter txFilter = parseTxFilter( arguments.get( ARG_TXFILTER, null ) ); PrintStream out = System.out; boolean redirectsToFile = arguments.getBoolean( ARG_TOFILE ); if ( redirectsToFile )
@Test void shouldRecognizeFlagsOfAnyForm() { // Given Args args = Args.withFlags( "flag1", "flag2", "flag3" ).parse( "-key1=Foo", "-flag1", "-key1", "Bar", "-flag2=true", "-key3=Baz", "-flag3", "true" ); // When List<String> orphans = args.orphans(); // Then assertTrue( orphans.isEmpty(), "Orphan args expected to be empty, but were: " + orphans ); assertTrue( args.getBoolean( "flag1", false, true ) ); assertTrue( args.getBoolean( "flag2", false, false ) ); assertTrue( args.getBoolean( "flag3", false, false ) ); }
@Test void shouldStillAllowExplicitValuesForFlags() { // Given Args args = Args.withFlags( "foo", "bar" ).parse("-foo=false", "--bar"); // When List<String> orphans = args.orphans(); // Then assertEquals( Arrays.<String>asList() , orphans ); assertFalse( args.getBoolean( "foo", false, false ) ); assertTrue( args.getBoolean( "bar", false, true ) ); }
@Test void shouldHandleOnlyFlagsAndNoArgs() { // Given Args args = Args.withFlags( "foo", "bar" ).parse("-foo", "--bar"); // When List<String> orphans = args.orphans(); // Then assertEquals( Collections.<String>emptyList(), orphans ); assertTrue( args.getBoolean( "foo", false, true ) ); assertTrue( args.getBoolean( "bar", false, true ) ); }
public static void main( String[] args ) throws Exception { Args arg = Args.withFlags( HEAP ).parse( args == null ? new String[0] : args ); boolean doHeapDump = arg.getBoolean( HEAP, false, true ); String[] containing = arg.orphans().toArray( new String[arg.orphans().size()] ); String dumpDir = arg.get( DIR, "data" ); new DumpProcessInformation( FormattedLogProvider.toOutputStream( System.out ), new File( dumpDir ) ).dumpRunningProcesses( doHeapDump, containing ); }
@Test void shouldHandleMixtureOfFlagsAndOrphanParams() { // Given Args args = Args.withFlags( "big", "soft", "saysMeow" ).parse( "-big", "-size=120", "-soft=true", "withStripes", "-saysMeow=false", "-name=ShereKhan", "badTiger" ); // When List<String> orphans = args.orphans(); // Then assertEquals( Arrays.asList( "withStripes", "badTiger" ), orphans ); assertEquals( 120, args.getNumber( "size", 0 ).intValue() ); assertEquals( "ShereKhan", args.get( "name" ) ); assertTrue( args.getBoolean( "big", false, true ) ); assertTrue( args.getBoolean( "soft", false, false ) ); assertFalse( args.getBoolean( "saysMeow", true, true ) ); }
@Test void shouldHandleFlagSpecifiedAsLastArgument() { // Given Args args = Args.withFlags( "flag1", "flag2" ).parse( "-key=Foo", "-flag1", "false", "-value", "Bar", "-flag2", "false" ); // When List<String> orphans = args.orphans(); // Then assertTrue( orphans.isEmpty(), "Orphan args expected to be empty, but were: " + orphans ); assertEquals( "Foo", args.get( "key" ) ); assertEquals( "Bar", args.get( "value" ) ); assertFalse( args.getBoolean( "flag1", true ) ); assertFalse( args.getBoolean( "flag2", true ) ); }
fs.mkdirs( logsDir ); skipBadEntriesLogging = args.getBoolean( Options.SKIP_BAD_ENTRIES_LOGGING.key(), (Boolean) Options.SKIP_BAD_ENTRIES_LOGGING.defaultValue(), false); if ( !skipBadEntriesLogging ) enableStacktrace = args.getBoolean( Options.STACKTRACE.key(), Boolean.FALSE, Boolean.TRUE ); processors = args.getNumber( Options.PROCESSORS.key(), null ); idType = args.interpretOption( Options.ID_TYPE.key(), skipBadRelationships = args.getBoolean( Options.SKIP_BAD_RELATIONSHIPS.key(), (Boolean)Options.SKIP_BAD_RELATIONSHIPS.defaultValue(), true ); skipDuplicateNodes = args.getBoolean( Options.SKIP_DUPLICATE_NODES.key(), (Boolean)Options.SKIP_DUPLICATE_NODES.defaultValue(), true ); ignoreExtraColumns = args.getBoolean( Options.IGNORE_EXTRA_COLUMNS.key(), (Boolean)Options.IGNORE_EXTRA_COLUMNS.defaultValue(), true ); defaultHighIO = args.getBoolean( Options.HIGH_IO.key(), (Boolean)Options.HIGH_IO.defaultValue(), true ); dbConfig.augment( loadDbConfig( args.interpretOption( Options.ADDITIONAL_CONFIG.key(), Converters.optional(), Converters.toFile(), Validators.REGEX_FILE_EXISTS ) ) ); boolean allowCacheOnHeap = args.getBoolean( Options.CACHE_ON_HEAP.key(), (Boolean) Options.CACHE_ON_HEAP.defaultValue() ); configuration = importConfiguration( idType, csvConfiguration( args, defaultSettingsSuitableForTests ), badCollector ); in = defaultSettingsSuitableForTests ? new ByteArrayInputStream( EMPTY_BYTE_ARRAY ) : System.in; boolean detailedPrinting = args.getBoolean( Options.DETAILED_PROGRESS.key(), (Boolean) Options.DETAILED_PROGRESS.defaultValue() );
boolean highIo = args.getBoolean( ImportTool.Options.HIGH_IO.key() ); if ( args.getBoolean( "to-csv" ) )
public boolean version() { return args.getBoolean( VERSION_ARG, false ); } }
/** * Like calling {@link #getBoolean(String, Boolean, Boolean)} with {@code true} for * {@code defaultValueIfNoValue}, i.e. specifying {@code --myarg} will interpret it as {@code true}. * * @param key argument key. * @param defaultValueIfNotSpecified used if argument not specified. * @return argument boolean value depending on what was specified, see above. */ @Deprecated public Boolean getBoolean( String key, Boolean defaultValueIfNotSpecified ) { return getBoolean( key, defaultValueIfNotSpecified, Boolean.TRUE ); }
private BackupOutcome runBackupWithLegacyArgs( Args args ) throws ToolFailureException { String from = args.get( FROM ).trim(); Path to = Paths.get( args.get( TO ).trim() ); Config tuningConfiguration = readConfiguration( args ); boolean forensics = args.getBoolean( FORENSICS, false, true ); ConsistencyCheck consistencyCheck = parseConsistencyChecker( args ); long timeout = args.getDuration( TIMEOUT, BackupClient.BIG_READ_TIMEOUT ); URI backupURI = resolveBackupUri( from, args, tuningConfiguration ); HostnamePort hostnamePort = newHostnamePort( backupURI ); return executeBackup( hostnamePort, to, consistencyCheck, tuningConfiguration, timeout, forensics ); }
private static ConsistencyCheck parseConsistencyChecker( Args args ) { boolean verify = args.getBoolean( VERIFY, true, true ); if ( verify ) { String consistencyCheckerName = args.get( CONSISTENCY_CHECKER, ConsistencyCheck.FULL.name(), ConsistencyCheck.FULL.name() ); return ConsistencyCheck.fromString( consistencyCheckerName ); } return ConsistencyCheck.NONE; }