Example usage for com.google.common.collect ImmutableList of

List of usage examples for com.google.common.collect ImmutableList of

Introduction

In this page you can find the example usage for com.google.common.collect ImmutableList of.

Prototype

public static <E> ImmutableList<E> of(E element) 

Source Link

Usage

From source file:org.attribyte.api.pubsub.impl.client.ReplicationTestEndpoint.java

public static void main(String[] args) throws Exception {

    Properties props = new Properties();
    FileInputStream fis = new FileInputStream(args[0]);
    props.load(fis);/*  w  w  w.  j a  va 2s.  c o m*/
    fis.close();

    String _hubURL = props.getProperty("hub.url");
    if (_hubURL == null) {
        System.err.println("The 'hub.url' must be specified");
        System.exit(1);
    }

    if (_hubURL.endsWith("/")) {
        _hubURL = _hubURL.substring(0, _hubURL.length() - 1);
    }

    final String hubURL = _hubURL;

    String _replicationTopicURL = props.getProperty("hub.replicationTopic");
    if (Strings.isNullOrEmpty(_replicationTopicURL)) {
        System.err.println("The 'hub.replicationTopic' must be specified");
        System.exit(1);
    }

    if (!_replicationTopicURL.startsWith("/")) {
        _replicationTopicURL = "/" + _replicationTopicURL;
    }

    final String replicationTopicURL = _replicationTopicURL;

    String hubUsername = props.getProperty("hub.username");
    String hubPassword = props.getProperty("hub.password");
    final Optional<BasicAuth> hubAuth;
    if (hubUsername != null && hubPassword != null) {
        hubAuth = Optional.of(new BasicAuth(hubUsername, hubPassword));
    } else {
        hubAuth = Optional.absent();
    }

    Topic replicationTopic = new Topic.Builder().setTopicURL(replicationTopicURL).setId(2L).create();

    String listenAddress = props.getProperty("endpoint.listenAddress", "127.0.0.1");
    int listenPort = Integer.parseInt(props.getProperty("endpoint.listenPort", "8088"));
    String endpointUsername = props.getProperty("endpoint.username");
    String endpointPassword = props.getProperty("endpoint.password");
    final Optional<BasicAuth> endpointAuth;
    if (!Strings.isNullOrEmpty(endpointUsername) && !Strings.isNullOrEmpty(endpointPassword)) {
        endpointAuth = Optional.of(new BasicAuth(endpointUsername, endpointPassword));
    } else {
        endpointAuth = Optional.absent();
    }

    final AtomicLong completeCount = new AtomicLong();

    final NotificationEndpoint notificationEndpoint = new NotificationEndpoint(listenAddress, listenPort,
            endpointAuth, ImmutableList.of(replicationTopic), new NotificationEndpoint.Callback() {
                @Override
                public boolean notification(final Notification notification) {
                    byte[] body = notification.getContent().toByteArray();
                    System.out.println(new String(body, Charsets.UTF_8));
                    Collection<Header> headers = notification.getHeaders();
                    if (headers != null) {
                        for (Header header : headers) {
                            System.out.println(header.toString());
                        }
                    }
                    completeCount.incrementAndGet();
                    return true;
                }
            });

    notificationEndpoint.start();

    String _endpointCallbackBase = props.getProperty("endpoint.callbackBase");
    if (_endpointCallbackBase == null) {
        System.err.println("The 'endpoint.callbackBase' must be specified");
        System.exit(1);
    }

    if (_endpointCallbackBase.endsWith("/")) {
        _endpointCallbackBase = _endpointCallbackBase.substring(0, _endpointCallbackBase.length() - 1);
    }

    final String endpointCallbackBase = _endpointCallbackBase;

    final SubscriptionClient subscriptionClient = new SubscriptionClient();
    subscriptionClient.start();
    SubscriptionClient.Result res = subscriptionClient.postSubscriptionRequest(replicationTopicURL,
            hubURL + "/subscribe", endpointCallbackBase + replicationTopicURL, 3600 * 24 * 365 * 5,
            endpointAuth, hubAuth);

    if (res.isError) {
        System.err.println("Problem creating subscription: " + res.code);
        if (res.message.isPresent()) {
            System.err.println(res.message.get());
        }
        if (res.cause.isPresent()) {
            res.cause.get().printStackTrace();
        }
    } else {
        System.out.println("Subscription created!");
    }

    long elapsedMillis = 0L;
    long maxMillis = 30000L;
    while (elapsedMillis < maxMillis) {
        Thread.sleep(5000L);
        System.out.println("Completed " + completeCount.get());
        elapsedMillis += 5000L;
    }

    System.out.println("Unsubscribing...");

    subscriptionClient.postUnsubscribeRequest(replicationTopicURL, hubURL + "/subscribe",
            endpointCallbackBase + replicationTopicURL, endpointAuth, hubAuth);

    Thread.sleep(5000L);

    System.out.println("Shutting down subscription client...");

    subscriptionClient.shutdown();

    System.out.println("Shutting down notification endpoint...");
    notificationEndpoint.stop();

    System.out.println("Notification endpoint stopped...");
}

From source file:com.ibm.og.cli.ObjectGenerator.java

public static void main(final String[] args) {
    timestampStart = System.currentTimeMillis();
    final OGGetOpt getopt = new OGGetOpt();
    final Cli cli = Application.cli("og", getopt, args);
    if (cli.shouldStop()) {
        if (cli.help()) {
            cli.printUsage();/* w  w  w.  ja va2s . c o  m*/
        } else if (cli.version()) {
            cli.printVersion();
        } else if (cli.error()) {
            cli.printErrors();
            cli.printUsage();
            timestampStop = System.currentTimeMillis();
            logSummary(timestampStart, timestampStop, Application.TEST_CONFIG_ERROR,
                    ImmutableList.of("Invalid Arguments"));
            Application.exit(Application.TEST_CONFIG_ERROR);

        }
        timestampStop = System.currentTimeMillis();
        logSummary(timestampStart, timestampStop, Application.TEST_SUCCESS,
                ImmutableList.of(Application.TEST_SUCCESS_MSG));
        Application.exit(Application.TEST_SUCCESS);
    }

    final CountDownLatch shutdownLatch = new CountDownLatch(1);

    logBanner();
    _consoleLogger.info("Configuring...");

    try {

        try {
            wireDependencies(cli, getopt);
        } catch (Exception e) {
            _logger.error("Exception while setting up dependencies", e);
            _consoleLogger.error("Test Error. See og.log for details");
            logConsoleException(e);
            logExceptionToFile(e);
            timestampStop = System.currentTimeMillis();
            logSummary(timestampStart, timestampStop, Application.TEST_CONFIG_ERROR,
                    ImmutableList.of(String.format("Configuration error %s", e.getMessage())));
            Application.exit(Application.TEST_CONFIG_ERROR);
        }

        OGLog4jShutdownCallbackRegistry.setOGShutdownHook((new ShutdownHook(test, shutdownLatch)));

        final LoadTestResult result = run(test, objectManager, statistics, gson);

        shutdownLatch.countDown();

        // slight race here; if shutdown hook completes prior to the exit line below
        // if the test completes whether it passes or fails, the summary is written in the test results callback
        if (!result.success) {
            Application.exit(Application.TEST_ERROR);
        }
    } catch (final Exception e) {
        _logger.error("Exception while configuring and running test", e);
        _consoleLogger.error("Test Error. See og.log for details");
        logConsoleException(e);
        logExceptionToFile(e);
        timestampStop = System.currentTimeMillis();
        logSummary(timestampStart, timestampStop, Application.TEST_ERROR,
                ImmutableList.of(String.format("Test error %s", e.getMessage())));
        Application.exit(Application.TEST_ERROR);
    }

    Application.exit(Application.TEST_SUCCESS);
}

From source file:com.easymargining.replication.eurex.EurexPrismaEtdMarginClient.java

public static void main(String[] args) throws IOException {

    // Initialize environment with data
    MarginEnvironment environment = MarginEnvironmentFactory
            .buildBasicEnvironment(new EurexPrismaReplication());

    // Use file resolver utility to discover data from standard Eurex directory structure
    MarketDataFileResolver fileResolver = new MarketDataFileResolver("eurex/marketData", s_valuationDate);

    // Create ETD data load request, pointing to classpath, and load
    EurexEtdMarketDataLoadRequest etdDataLoadRequest = MarketDataLoaders.etdRequest(fileResolver);
    EurexMarketDataLoadRequest loadRequest = EurexMarketDataLoadRequest.etdMarketDataRequest(s_valuationDate,
            etdDataLoadRequest);//from w  ww.  j av a 2s . co m
    environment.getMarginData().loadData(loadRequest);

    // Obtain portfolio, loaded from a trade file on the classpath
    URL tradeFile = FileResources.byPath("eurex/trade/etdTrades.csv");
    OgmLinkResolver linkResolver = environment.getInjector().getInstance(OgmLinkResolver.class);
    MarginPortfolio portfolio = PortfolioLoader.load(ImmutableList.of(tradeFile), linkResolver);

    // Build PV calculation request
    EurexPrismaReplicationRequest pvRequest = getPvCalculationRequest();

    // Build IM calculation request
    EurexPrismaReplicationRequest imRequest = getImCalculationRequest();

    // Grab calculator
    MarginCalculator calculator = environment.getMarginCalculator();

    // Run PV request
    s_logger.info("Running PV request");
    MarginResults pvResults = calculator.calculate(portfolio, pvRequest);

    // Print results
    Table<TradeWrapper<?>, TradeMeasure, Result<?>> tradePvResults = pvResults.getTradeResults().getResults();
    String stringPvTable = TradeMeasureResultFormatter.formatter().truncateAfter(200).format(tradePvResults);
    System.out.println("PV results:\n" + stringPvTable);

    // Run IM request
    s_logger.info("Running IM request");
    MarginResults imResults = calculator.calculate(portfolio, imRequest);

    // Load Eurex Risk Measure
    Set<Triple<String, String, String>> liquidationGroupDef = null;
    Map<String, Set<String>> liquidationGroupDefinitions = new HashMap<>();
    try {
        liquidationGroupDef = (new EurexRiskMeasureConfigParser()
                .parse(etdDataLoadRequest.getRiskMeasureConfig())).keySet();
        Iterator<Triple<String, String, String>> liquidityGroupDefIter = liquidationGroupDef.iterator();
        while (liquidityGroupDefIter.hasNext()) {
            Triple<String, String, String> stringStringStringTriple = liquidityGroupDefIter.next();
            Set<String> currentLiquidationGroupSplit = liquidationGroupDefinitions
                    .get(stringStringStringTriple.getFirst());
            if (currentLiquidationGroupSplit == null) {
                currentLiquidationGroupSplit = new ConcurrentSkipListSet<>();
                currentLiquidationGroupSplit.add(stringStringStringTriple.getSecond());
                liquidationGroupDefinitions.put(stringStringStringTriple.getFirst(),
                        currentLiquidationGroupSplit);
            }
            currentLiquidationGroupSplit.add(stringStringStringTriple.getSecond());
        }

    } catch (IOException e) {
        e.printStackTrace();
    }
    //-------------------------------

    // Build Output Result.
    MarginResult result = new MarginResult();
    result.setPortfolioMarginResults(new ArrayList());
    List<LiquidationGroupMarginResult> liquidationGroupMarginResults = null;
    CurrencyAmount[] currencyAmounts = imResults.getPortfolioResults().getValues()
            .get("Total", EurexPrismaReplicationRequests.portfolioMeasures().im()).getValue()
            .getCurrencyAmounts();

    List<String> liquidationGroups = new ArrayList(liquidationGroupDefinitions.keySet());

    for (int i = 0; i < currencyAmounts.length; i++) {
        currencyAmounts[i].getCurrency();
        currencyAmounts[i].getAmount();

        // For Each Liquidation Group
        for (int j = 0; j < liquidationGroups.size(); j++) {

            String liquidationGroupName = liquidationGroups.get(j);

            liquidationGroupMarginResults = new ArrayList();
            result.getPortfolioMarginResults()
                    .add(new PortfolioMarginResult(liquidationGroupName,
                            currencyAmounts[i].getCurrency().getCode(), currencyAmounts[i].getAmount(),
                            liquidationGroupMarginResults));

            // Identify IM for Liquidation Group
            MultipleCurrencyAmount imgroup = null;

            Result<MultipleCurrencyAmount> imgroupMarginResult = imResults.getPortfolioResults().getValues()
                    .get("Total",
                            EurexPrismaReplicationRequests.portfolioMeasures().groupIm(liquidationGroupName));

            if (imgroupMarginResult != null) {
                imgroup = imgroupMarginResult.getValue();
            }

            if (imgroup != null) {
                List<LiquidationGroupSplitMarginResult> liquidationGroupSplitMarginResults = new ArrayList();
                double value = imgroup.getAmount(currencyAmounts[i].getCurrency());
                liquidationGroupMarginResults.add(new LiquidationGroupMarginResult(liquidationGroupName, value,
                        liquidationGroupSplitMarginResults));

                // For all Liquidation Group Split
                List<String> liquidationGroupSplits = new ArrayList(
                        liquidationGroupDefinitions.get(liquidationGroupName));
                for (int k = 0; k < liquidationGroupSplits.size(); k++) {
                    String liquidationGroupSplitName = liquidationGroupSplits.get(k);

                    MultipleCurrencyAmount imLGS = null;
                    MultipleCurrencyAmount liquidityAddon = null;
                    MultipleCurrencyAmount liquidityAddonEtd = null;
                    MultipleCurrencyAmount liquidityAddonOtc = null;
                    MultipleCurrencyAmount longOptionCredit = null;
                    MultipleCurrencyAmount var = null;

                    //Identify Market Risk IM for liquidation group
                    Result<MultipleCurrencyAmount> imLGSMarginResult = imResults.getPortfolioResults()
                            .getValues().get("Total", EurexPrismaReplicationRequests.portfolioMeasures()
                                    .groupIm(liquidationGroupSplitName));
                    if (imLGSMarginResult != null) {
                        imLGS = imLGSMarginResult.getValue();
                    }

                    Result<MultipleCurrencyAmount> liquidityAddonMarginResult = imResults.getPortfolioResults()
                            .getValues().get("Total", EurexPrismaReplicationRequests.portfolioMeasures()
                                    .liquidityAddon(liquidationGroupSplitName));

                    if (liquidityAddonMarginResult != null) {
                        liquidityAddon = liquidityAddonMarginResult.getValue();
                    }

                    Result<MultipleCurrencyAmount> liquidityAddonEtdMarginResult = imResults
                            .getPortfolioResults().getValues().get("Total", EurexPrismaReplicationRequests
                                    .portfolioMeasures().liquidityAddonEtd(liquidationGroupSplitName));
                    if (liquidityAddonEtdMarginResult != null) {
                        liquidityAddonEtd = liquidityAddonEtdMarginResult.getValue();
                    }

                    Result<MultipleCurrencyAmount> liquidityAddonOtcMarginResult = imResults
                            .getPortfolioResults().getValues().get("Total", EurexPrismaReplicationRequests
                                    .portfolioMeasures().liquidityAddonOtc(liquidationGroupSplitName));

                    if (liquidityAddonOtcMarginResult != null) {
                        liquidityAddonOtc = liquidityAddonOtcMarginResult.getValue();
                    }

                    Result<MultipleCurrencyAmount> longOptionCreditMarginResult = imResults
                            .getPortfolioResults().getValues().get("Total", EurexPrismaReplicationRequests
                                    .portfolioMeasures().longOptionCredit(liquidationGroupSplitName));

                    if (longOptionCreditMarginResult != null) {
                        longOptionCredit = longOptionCreditMarginResult.getValue();
                    }

                    Result<MultipleCurrencyAmount> varMarginResult = imResults.getPortfolioResults().getValues()
                            .get("Total", EurexPrismaReplicationRequests.portfolioMeasures()
                                    .var(liquidationGroupSplitName));

                    if (varMarginResult != null) {
                        var = varMarginResult.getValue();
                    }

                    LiquidityRiskAdjustmentResult liquidityRiskAdjustmentResult = new LiquidityRiskAdjustmentResult();
                    MarketRiskIMResult marketRiskIMResult = new MarketRiskIMResult();

                    if (liquidityAddon != null) {
                        liquidityRiskAdjustmentResult.setTotalLiquidityRiskAdjustmentAddOn(
                                liquidityAddon.getAmount(currencyAmounts[i].getCurrency()));
                    }
                    if (liquidityAddonEtd != null) {
                        liquidityRiskAdjustmentResult.setEtdliquidityRiskAdjustmentAddOnPart(
                                liquidityAddonEtd.getAmount(currencyAmounts[i].getCurrency()));
                    }
                    if (liquidityAddonOtc != null) {
                        liquidityRiskAdjustmentResult.setOtcliquidityRiskAdjustmentAddOnPart(
                                liquidityAddonOtc.getAmount(currencyAmounts[i].getCurrency()));
                    }
                    if (longOptionCredit != null) {
                        liquidityRiskAdjustmentResult.setLongOptionCreditAddOn(
                                longOptionCredit.getAmount(currencyAmounts[i].getCurrency()));
                    }

                    if (imLGS != null) {
                        Double valueImLGS = imLGS.getAmount(currencyAmounts[i].getCurrency());

                        liquidationGroupSplitMarginResults
                                .add(new LiquidationGroupSplitMarginResult(liquidationGroupSplitName,
                                        valueImLGS, liquidityRiskAdjustmentResult, marketRiskIMResult));
                    }

                }
            }
        }
    }
    // ---

    // Print results
    String imResultTable = PortfolioMeasureResultFormatter.formatter().format(imResults.getPortfolioResults());
    System.out.println("Portfolio results:\n" + imResultTable);

    System.out.println("IM result: " + imResults.getPortfolioResults().getValues().get("Total",
            EurexPrismaReplicationRequests.portfolioMeasures().im()));
    System.out.println("Historical VAR result: "
            + imResults.getPortfolioResults().getValues().get("Total", EurexPrismaReplicationRequests
                    .portfolioMeasures().var("PFI01_HP2_T0-99999~FILTERED_HISTORICAL_VAR_2")));

    CheckResults.checkMarginResults(imResults);

}

From source file:com.opengamma.margining.example.EurexPrismaCommandLineExample.java

/**
 * Main entry point.// w ww  .j  ava  2  s . c  om
 *
 * @param args  command-line arguments
 */
public static void main(String[] args) throws ParseException {
    Options commandLineOptions = getCommandLineOptions();
    PosixParser commandLineParser = new PosixParser();
    CommandLine commandLine = commandLineParser.parse(commandLineOptions, args);

    LocalDate valuationDate = LocalDate.parse(commandLine.getOptionValue(VALUATION_DATE_OPTION));
    String marketDataDirectory = commandLine.getOptionValue(MARKET_DATA_DIR_OPTION);
    String portfolioFile = commandLine.getOptionValue(PORTFOLIO_FILE_OPTION);

    // Initialize environment with data
    MarginEnvironment environment = MarginEnvironmentFactory
            .buildBasicEnvironment(new EurexPrismaReplication());

    // Use file resolver utility to discover data from standard Eurex directory structure
    MarketDataFileResolver fileResolver = new MarketDataFileResolver("file:" + marketDataDirectory,
            valuationDate);

    // Create fixings and holidays load request, and load
    MarketDataLoaders.loadGeneralData(environment.getMarginData(), fileResolver);

    // Create data load request and load
    s_logger.info("Loading market data");
    EurexOtcMarketDataLoadRequest otcDataLoadRequest = MarketDataLoaders.otcRequest(fileResolver);
    EurexEtdMarketDataLoadRequest etdDataLoadRequest = MarketDataLoaders.etdRequest(fileResolver);
    EurexMarketDataLoadRequest loadRequest = EurexMarketDataLoadRequest.marketDataRequest(valuationDate,
            otcDataLoadRequest, etdDataLoadRequest);
    environment.getMarginData().loadData(loadRequest);

    // Load portfolio
    s_logger.info("Loading portfolio");
    URL portfolioFileUrl = FileResources.byPath("file:" + portfolioFile);
    OgmLinkResolver linkResolver = environment.getInjector().getInstance(OgmLinkResolver.class);
    MarginPortfolio portfolio = PortfolioLoader.load(ImmutableList.of(portfolioFileUrl), linkResolver);

    // Build calculation request
    EurexPrismaReplicationRequest calcRequest = getCalculationRequest(valuationDate);

    // Get calculator
    MarginCalculator calculator = environment.getMarginCalculator();

    // Run request
    s_logger.info("Running calculation request");
    MarginResults calcResults = calculator.calculate(portfolio, calcRequest);

    // Print trade-level results
    Table<TradeWrapper<?>, TradeMeasure, Result<?>> tradeResults = calcResults.getTradeResults().getResults();
    String tradeResultsTable = TradeMeasureResultFormatter.formatter().truncateAfter(200).format(tradeResults);
    System.out.println("Trade results:\n" + tradeResultsTable);

    // Print portfolio-level results
    String portfolioResultsTable = PortfolioMeasureResultFormatter.formatter()
            .format(calcResults.getPortfolioResults());
    System.out.println("Portfolio results:\n" + portfolioResultsTable);

    Result<MultipleCurrencyAmount> imResult = calcResults.getPortfolioResults().getValues().get("Total",
            EurexPrismaReplicationRequests.portfolioMeasures().im());
    if (imResult.isSuccess()) {
        System.out.println("IM result: " + imResult.getValue());
    } else {
        System.err.println("IM calculation failed: " + imResult.getFailureMessage());
    }
}

From source file:io.v.syncslidepresenter.Main.java

public static void main(String[] args) throws SyncbaseServer.StartException, VException, IOException {
    Options options = new Options();
    JCommander commander = new JCommander(options);
    try {/*  w w w .  j a v  a 2 s.  c  o m*/
        commander.parse(args);
    } catch (ParameterException e) {
        logger.warning("Could not parse parameters: " + e.getMessage());
        commander.usage();
        return;
    }

    if (options.help) {
        commander.usage();
        return;
    }

    // Make command-Q do the same as closing the main frame (i.e. exit).
    System.setProperty("apple.eawt.quitStrategy", "CLOSE_ALL_WINDOWS");

    JFrame frame = new JFrame();
    enableOSXFullscreen(frame);
    frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    frame.setVisible(true);

    VContext baseContext = V.init();

    AccessList acl = new AccessList(ImmutableList.of(new BlessingPattern("...")), ImmutableList.<String>of());
    Permissions permissions = new Permissions(ImmutableMap.of("1", acl));
    String name = NamingUtil.join(options.mountPrefix, UUID.randomUUID().toString());
    logger.info("Mounting new syncbase server at " + name);
    VContext mountContext = SyncbaseServer.withNewServer(baseContext, new SyncbaseServer.Params()
            .withPermissions(permissions).withName(name).withStorageRootDir(options.storageRootDir));
    final Server server = V.getServer(mountContext);
    if (server.getStatus().getEndpoints().length > 0) {
        logger.info("Mounted syncbase server at the following endpoints: ");
        for (Endpoint e : server.getStatus().getEndpoints()) {
            logger.info("\t" + e);
        }
        logger.info("End of endpoint list");

        SyncbaseService service = Syncbase.newService("/" + server.getStatus().getEndpoints()[0]);
        SyncbaseApp app = service.getApp(SYNCBASE_APP);
        if (!app.exists(baseContext)) {
            app.create(baseContext, permissions);
        }
        Database db = app.getNoSqlDatabase(SYNCBASE_DB, null);
        if (!db.exists(baseContext)) {
            db.create(baseContext, permissions);
        }
        Table decks = db.getTable(DECKS_TABLE);
        if (!decks.exists(baseContext)) {
            decks.create(baseContext, permissions);
        }
        Table presentations = db.getTable(PRESENTATIONS_TABLE);
        if (!presentations.exists(baseContext)) {
            presentations.create(baseContext, permissions);
        }

        JPanel panel = new JPanel(new GridBagLayout());
        ScaleToFitJPanel presentationPanel = new ScaleToFitJPanel();
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.weightx = 1;
        constraints.weighty = 1;
        constraints.fill = GridBagConstraints.BOTH;
        panel.add(presentationPanel, constraints);
        frame.getContentPane().add(panel);
        frame.pack();

        Main m = new Main(baseContext, presentationPanel, db, decks, presentations);

        Presentation presentation = new Discovery(baseContext, options.mountPrefix, options.deckPrefix,
                options.maxMtScanCount).getPresentation();
        logger.info("Using presentation: " + presentation);
        m.joinPresentation(presentation, options.joinTimeoutSeconds, options.slideRowFormat);
    }
}

From source file:com.google.devtools.build.android.Aapt2ResourceShrinkingAction.java

public static void main(String[] args) throws Exception {
    final Profiler profiler = LoggingProfiler.createAndStart("shrink").startTask("flags");
    // Parse arguments.
    OptionsParser optionsParser = OptionsParser.newOptionsParser(Options.class, Aapt2ConfigOptions.class);
    optionsParser.enableParamsFileSupport(new ShellQuotedParamsFilePreProcessor(FileSystems.getDefault()));
    optionsParser.parseAndExitUponError(args);
    Aapt2ConfigOptions aapt2ConfigOptions = optionsParser.getOptions(Aapt2ConfigOptions.class);
    Options options = optionsParser.getOptions(Options.class);
    options.dependencyManifests = Converters.concatLists(options.dependencyManifests,
            options.deprecatedDependencyManifests);
    profiler.recordEndOf("flags").startTask("setup");

    final ListeningExecutorService executorService = ExecutorServiceCloser.createDefaultService();
    try (ScopedTemporaryDirectory scopedTmp = new ScopedTemporaryDirectory("android_resources_tmp");
            Closeable closer = ExecutorServiceCloser.createWith(executorService)) {

        Path workingResourcesDirectory = scopedTmp.subDirectoryOf("resources");
        final ResourceCompiler resourceCompiler = ResourceCompiler.create(executorService,
                workingResourcesDirectory, aapt2ConfigOptions.aapt2, aapt2ConfigOptions.buildToolsVersion);
        profiler.recordEndOf("setup").startTask("compile");

        final ResourcesZip resourcesZip = ResourcesZip.createFrom(options.resourcesZip,
                scopedTmp.subDirectoryOf("merged-resources"));
        final CompiledResources compiled = resourcesZip
                .shrink(options.dependencyManifests.stream().map(Path::toFile)
                        .map(manifestToPackageUsing(executorService)).map(futureToString()).collect(toSet()),
                        options.rTxt, options.shrunkJar, options.primaryManifest, options.proguardMapping,
                        options.log, scopedTmp.subDirectoryOf("shrunk-resources"))
                .writeArchiveTo(options.shrunkResources, false)
                .compile(resourceCompiler, workingResourcesDirectory);
        profiler.recordEndOf("compile");

        ResourceLinker.create(aapt2ConfigOptions.aapt2, scopedTmp.subDirectoryOf("linking"))
                .profileUsing(profiler)/*  w w w  .  jav a 2  s .c  o m*/
                .dependencies(ImmutableList.of(StaticLibrary.from(aapt2ConfigOptions.androidJar)))
                .link(compiled).copyPackageTo(options.shrunkApk).copyRTxtTo(options.rTxtOutput);
        profiler.recordEndOf("shrink");
    }
}

From source file:org.jclouds.examples.google.lb.MainApp.java

public static void main(String[] args) {
    if (args.length < PARAMETERS)
        throw new IllegalArgumentException(INVALID_SYNTAX);

    String jsonKeyFile = args[0];
    Action action = Action.valueOf(args[1].toUpperCase());

    // Read in JSON key.
    String fileContents = null;/*from   www. j  a  va  2 s  .  com*/
    try {
        fileContents = Files.toString(new File(jsonKeyFile), Charset.defaultCharset());
    } catch (IOException ex) {
        System.out.println("Error Reading the Json key file. Please check the provided path is correct.");
        System.exit(1);
    }

    Supplier<Credentials> credentialSupplier = new GoogleCredentialsFromJson(fileContents);

    // This demonstrates how to initialize a ComputeServiceContext using json key files.
    ComputeServiceContext context = ContextBuilder.newBuilder("google-compute-engine")
            .credentialsSupplier(credentialSupplier).buildView(ComputeServiceContext.class);

    Credentials credentials = credentialSupplier.get();

    GoogleComputeEngineApi googleApi = createGoogleComputeEngineApi(credentials.identity,
            credentials.credential);

    String project_name = googleApi.project().get().name();
    System.out.printf("Sucessfully Authenticated to project %s\n", project_name);

    InstanceApi instanceApi = googleApi.instancesInZone(DEFAULT_ZONE);

    switch (action) {
    case CREATE: {
        Metadata metadata = googleApi.project().get().commonInstanceMetadata();
        if (metadata.get("startup-script") != null && metadata.get("startup-script") != STARTUP_SCRIPT) {

            System.out.println("Project already has a startup script, exiting to avoid overwriting it.");
            System.exit(1);
        }
        System.out.println("Updating startup script");
        metadata.put("startup-script", STARTUP_SCRIPT);
        Operation operation = googleApi.project().setCommonInstanceMetadata(metadata);
        OperationApi operationsApi = googleApi.operations();
        WaitForOperation(operationsApi, operation);

        URI networkURL = googleApi.networks().get("default").selfLink();
        if (networkURL == null) {
            System.out.println(
                    "Your project does not have a default network. Please recreate the default network or try again with a new project");
            System.exit(1);
        }
        System.out.println("Creating:");

        // Add firewall rule to allow TCP on port 80
        FirewallOptions options = new FirewallOptions()
                .addAllowedRule(Firewall.Rule.create("tcp", ImmutableList.of("80")))
                .sourceRanges(ImmutableList.of("0.0.0.0/0"));
        //.addTargetTag(FIREWALL_TAG);
        operation = googleApi.firewalls().createInNetwork("jclouds-lb-firewall-tcp-80", networkURL, options);
        System.out.println(" - firewall");
        WaitForOperation(operationsApi, operation);

        URI machineTypeURL = googleApi.machineTypesInZone(DEFAULT_ZONE).get(DEFAULT_MACHINE_TYPE).selfLink();

        // Make requests to create instances.
        ArrayList<Operation> operations = new ArrayList<Operation>();
        for (int i = 0; i < NUM_INSTANCES; i++) {
            Operation o = instanceApi.create(NewInstance.create("jclouds-lb-instance-" + i, machineTypeURL,
                    networkURL, DEFAULT_IMAGE_URL));
            System.out.println(" - instance");
            operations.add(o);
        }

        ArrayList<URI> instances = new ArrayList<URI>();
        for (Operation op : operations) {
            WaitForOperation(operationsApi, op);
            instances.add(op.targetLink());
        }

        // Create Health Check
        HttpHealthCheckCreationOptions healthCheckOptions = new HttpHealthCheckCreationOptions.Builder()
                .checkIntervalSec(1).timeoutSec(1).buildWithDefaults();
        operation = googleApi.httpHeathChecks().insert("jclouds-lb-healthcheck", healthCheckOptions);
        System.out.println(" - http health check");
        WaitForOperation(operationsApi, operation);
        URI healthCheckURI = googleApi.httpHeathChecks().get("jclouds-lb-healthcheck").selfLink();

        // Create Target Pool
        TargetPoolCreationOptions targetPoolOptions = new TargetPoolCreationOptions.Builder(
                "jclouds-lb-target-pool").healthChecks(ImmutableList.of(healthCheckURI)).instances(instances)
                        .build();
        Operation targetPoolOperation = googleApi.targetPoolsInRegion(DEFAULT_REGION).create(targetPoolOptions);
        System.out.println(" - target pool");
        WaitForOperation(operationsApi, targetPoolOperation);

        // Create Forwarding Rule
        ForwardingRuleCreationOptions forwardingOptions = new ForwardingRuleCreationOptions.Builder()
                .ipProtocol(ForwardingRule.IPProtocol.TCP).target(targetPoolOperation.targetLink()).build();
        operation = googleApi.forwardingRulesInRegion(DEFAULT_REGION).create("jclouds-lb-forwarding",
                forwardingOptions);
        System.out.println(" - forwarding rule");
        WaitForOperation(operationsApi, operation);

        String ipAddress = googleApi.forwardingRulesInRegion(DEFAULT_REGION).get("jclouds-lb-forwarding")
                .ipAddress();
        System.out.println("Ready to recieve traffic at " + ipAddress);

        break;
    }
    case REQUEST: {
        // Find the created forwarding rule.
        ForwardingRule forwardingRule = googleApi.forwardingRulesInRegion(DEFAULT_REGION)
                .get("jclouds-lb-forwarding");
        if (forwardingRule == null) {
            System.out.println("jclouds-lb-forwarding rule does not exist. Have you successfully run create?");
            System.exit(1);
        }
        String ipAddress = googleApi.forwardingRulesInRegion(DEFAULT_REGION).get("jclouds-lb-forwarding")
                .ipAddress();
        System.out.printf("Found the forwarding rule! Try executing 'while true; do curl -m1 %s; done'\n",
                ipAddress);

        break;
    }
    case DELETE_STARTUP_SCRIPT: {
        System.out.println("removing startup script from project metadata");
        DeleteStartupScript(googleApi);
        break;
    }
    case DESTROY: {
        // Delete Forwarding Rule
        googleApi.forwardingRulesInRegion(DEFAULT_REGION).delete("jclouds-lb-forwarding");

        // Delete Target Pool
        googleApi.targetPoolsInRegion(DEFAULT_REGION).delete("jclouds-lb-target-pool");

        // Delete Health Check
        googleApi.httpHeathChecks().delete("jclouds-lb-healthcheck");

        // Delete Instances
        ArrayList<Operation> operations = new ArrayList<Operation>();
        for (int i = 0; i < NUM_INSTANCES; i++) {
            Operation o = instanceApi.delete("jclouds-lb-instance-" + i);
            operations.add(o);
        }

        // Delete Firewall Rule
        googleApi.firewalls().delete("jclouds-lb-firewall-tcp-80");

        // Delete Startup Script
        DeleteStartupScript(googleApi);

        System.out.println("ran cleanup");
        break;
    }
    }
}

From source file:com.google.devtools.build.android.Aapt2ResourcePackagingAction.java

public static void main(String[] args) throws Exception {
    Profiler profiler = LoggingProfiler.createAndStart("setup");
    OptionsParser optionsParser = OptionsParser.newOptionsParser(Options.class, Aapt2ConfigOptions.class);
    optionsParser.enableParamsFileSupport(new ShellQuotedParamsFilePreProcessor(FileSystems.getDefault()));
    optionsParser.parseAndExitUponError(args);
    aaptConfigOptions = optionsParser.getOptions(Aapt2ConfigOptions.class);
    options = optionsParser.getOptions(Options.class);

    try (ScopedTemporaryDirectory scopedTmp = new ScopedTemporaryDirectory("android_resources_tmp")) {
        final Path tmp = scopedTmp.getPath();
        final Path mergedAssets = tmp.resolve("merged_assets");
        final Path mergedResources = tmp.resolve("merged_resources");
        final Path filteredResources = tmp.resolve("filtered_resources");

        final Path densityManifest = tmp.resolve("manifest-filtered/AndroidManifest.xml");

        final Path processedManifest = tmp.resolve("manifest-processed/AndroidManifest.xml");
        final Path databindingResourcesRoot = Files
                .createDirectories(tmp.resolve("android_data_binding_resources"));
        final Path compiledResources = Files.createDirectories(tmp.resolve("compiled"));
        final Path linkedOut = Files.createDirectories(tmp.resolve("linked"));

        final List<String> densitiesToFilter = options.prefilteredResources.isEmpty() ? options.densities
                : Collections.<String>emptyList();

        final List<String> densitiesForManifest = densitiesToFilter.isEmpty() ? options.densitiesForManifest
                : densitiesToFilter;/*  w  w w.j a  v  a 2 s .  co  m*/

        profiler.recordEndOf("setup").startTask("merging");

        // Checks for merge conflicts.
        MergedAndroidData mergedAndroidData = AndroidResourceMerger
                .mergeData(options.primaryData, options.directData, options.transitiveData, mergedResources,
                        mergedAssets, null /* cruncher. Aapt2 automatically chooses to crunch or not. */,
                        options.packageType, options.symbolsOut, options.prefilteredResources,
                        false /* throwOnResourceConflict */)
                .filter(new DensitySpecificResourceFilter(densitiesToFilter, filteredResources,
                        mergedResources),
                        new DensitySpecificManifestProcessor(densitiesForManifest, densityManifest));

        profiler.recordEndOf("merging");

        final ListeningExecutorService executorService = ExecutorServiceCloser.createDefaultService();
        try (final Closeable closeable = ExecutorServiceCloser.createWith(executorService)) {
            profiler.startTask("compile");
            final ResourceCompiler compiler = ResourceCompiler.create(executorService, compiledResources,
                    aaptConfigOptions.aapt2, aaptConfigOptions.buildToolsVersion);

            CompiledResources compiled = options.primaryData
                    .processDataBindings(
                            options.dataBindingInfoOut, options.packageForR, databindingResourcesRoot)
                    .compile(compiler, compiledResources)
                    .processManifest(manifest -> AndroidManifestProcessor.with(STD_LOGGER).processManifest(
                            options.applicationId, options.versionCode, options.versionName, manifest,
                            processedManifest))
                    .processManifest(manifest -> new DensitySpecificManifestProcessor(densitiesForManifest,
                            densityManifest).process(manifest));
            profiler.recordEndOf("compile").startTask("link");
            // Write manifestOutput now before the dummy manifest is created.
            if (options.manifestOutput != null) {
                AndroidResourceOutputs.copyManifestToOutput(compiled, options.manifestOutput);
            }

            List<CompiledResources> compiledResourceDeps =
                    // Last defined dependencies will overwrite previous one, so always place direct
                    // after transitive.
                    concat(options.transitiveData.stream(), options.directData.stream())
                            .map(DependencyAndroidData::getCompiledSymbols).collect(toList());

            List<Path> assetDirs = concat(options.transitiveData.stream(), options.directData.stream())
                    .flatMap(dep -> dep.assetDirs.stream()).collect(toList());
            assetDirs.addAll(options.primaryData.assetDirs);

            final PackagedResources packagedResources = ResourceLinker
                    .create(aaptConfigOptions.aapt2, linkedOut).profileUsing(profiler)
                    .dependencies(ImmutableList.of(StaticLibrary.from(aaptConfigOptions.androidJar)))
                    .include(compiledResourceDeps).withAssets(assetDirs)
                    .buildVersion(aaptConfigOptions.buildToolsVersion).filterToDensity(densitiesToFilter)
                    .link(compiled).copyPackageTo(options.packagePath).copyProguardTo(options.proguardOutput)
                    .copyMainDexProguardTo(options.mainDexProguardOutput).createSourceJar(options.srcJarOutput)
                    .copyRTxtTo(options.rOutput);
            profiler.recordEndOf("link");
            if (options.resourcesOutput != null) {
                profiler.startTask("package");
                // The compiled resources and the merged resources should be the same.
                // TODO(corysmith): Decompile or otherwise provide the exact resources in the apk.
                ResourcesZip
                        .from(mergedAndroidData.getResourceDir(), mergedAndroidData.getAssetDir(),
                                packagedResources.resourceIds())
                        .writeTo(options.resourcesOutput, false /* compress */);
                profiler.recordEndOf("package");
            }
        }
    } catch (MergingException e) {
        logger.severe("Merging exception: " + e.getMessage());
        // throw an error, as system.exit will fail tests.
        throw new RuntimeException();
    } catch (IOException e) {
        logger.severe("File error: " + e.getMessage());
        // throw an error, as system.exit will fail tests.
        throw new RuntimeException();
    } catch (Exception e) {
        throw e;
    }
}

From source file:com.opengamma.strata.function.calculation.swap.SwapMeasureCalculations.java

static LegAmounts calculateLegInitialNotional(SwapTrade trade) {
    List<Pair<SwapLeg, CurrencyAmount>> notionals = trade.getProduct().getLegs().stream()
            .map(leg -> Pair.of(leg, buildLegNotional(leg))).collect(toList());
    CurrencyAmount firstNotional = notionals.stream().filter(pair -> pair.getSecond() != NOT_FOUND)
            .map(pair -> pair.getSecond()).findFirst()
            .orElseThrow(() -> new IllegalArgumentException("No notional found on any swap leg"));
    notionals = notionals.stream()//from   w w w . j  av a  2s  .com
            .map(pair -> pair.getSecond() != NOT_FOUND ? pair : Pair.of(pair.getFirst(), firstNotional))
            .collect(toList());
    ImmutableList<LegAmount> legAmounts = notionals.stream()
            .map(pair -> SwapLegAmount.of(pair.getFirst(), pair.getSecond())).collect(toImmutableList());
    return LegAmounts.of(legAmounts);
}

From source file:com.farhad.ngram.lang.detector.ngram.NgramExtractor.java

public static NgramExtractor gramLength(int gramLength) {
    return new NgramExtractor(ImmutableList.of(gramLength), null, null);
}