Java tutorial
/** * Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.integration.tool.config; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.TreeSet; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.HelpFormatter; import org.apache.commons.cli.Option; import org.apache.commons.cli.OptionBuilder; import org.apache.commons.cli.Options; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.threeten.bp.ZonedDateTime; import com.google.common.collect.ImmutableList; import com.opengamma.OpenGammaRuntimeException; import com.opengamma.analytics.util.time.TimeCalculator; import com.opengamma.bbg.BloombergConstants; import com.opengamma.bbg.referencedata.ReferenceDataProvider; import com.opengamma.bbg.util.BloombergDataUtils; import com.opengamma.bbg.util.BloombergTickerParserBondFutureOption; import com.opengamma.bbg.util.BloombergTickerParserCommodityFutureOption; import com.opengamma.bbg.util.BloombergTickerParserEQIndexOption; import com.opengamma.bbg.util.BloombergTickerParserEQVanillaOption; import com.opengamma.bbg.util.BloombergTickerParserFutureOption; import com.opengamma.bbg.util.BloombergTickerParserIRFutureOption; import com.opengamma.component.tool.AbstractTool; import com.opengamma.core.config.impl.ConfigItem; import com.opengamma.core.id.ExternalSchemes; import com.opengamma.core.value.MarketDataRequirementNames; import com.opengamma.engine.value.SurfaceAndCubePropertyNames; import com.opengamma.financial.analytics.model.InstrumentTypeProperties; import com.opengamma.financial.analytics.volatility.surface.BloombergBondFutureOptionVolatilitySurfaceInstrumentProvider; import com.opengamma.financial.analytics.volatility.surface.BloombergCommodityFutureOptionVolatilitySurfaceInstrumentProvider; import com.opengamma.financial.analytics.volatility.surface.BloombergEquityFutureOptionVolatilitySurfaceInstrumentProvider; import com.opengamma.financial.analytics.volatility.surface.BloombergFutureOptionVolatilitySurfaceInstrumentProvider; import com.opengamma.financial.analytics.volatility.surface.BloombergIRFutureOptionVolatilitySurfaceInstrumentProvider; import com.opengamma.financial.analytics.volatility.surface.SurfaceAndCubeQuoteType; import com.opengamma.financial.analytics.volatility.surface.SurfaceInstrumentProvider; import com.opengamma.financial.analytics.volatility.surface.VolatilitySurfaceDefinition; import com.opengamma.financial.analytics.volatility.surface.VolatilitySurfaceSpecification; import com.opengamma.financial.security.FinancialSecurity; import com.opengamma.financial.security.FinancialSecurityVisitorAdapter; import com.opengamma.financial.security.bond.GovernmentBondSecurity; import com.opengamma.financial.security.equity.EquitySecurity; import com.opengamma.financial.security.future.AgricultureFutureSecurity; import com.opengamma.financial.security.future.BondFutureSecurity; import com.opengamma.financial.security.future.EnergyFutureSecurity; import com.opengamma.financial.security.future.EquityFutureSecurity; import com.opengamma.financial.security.future.InterestRateFutureSecurity; import com.opengamma.financial.security.future.MetalFutureSecurity; import com.opengamma.financial.security.option.BondFutureOptionSecurity; import com.opengamma.financial.security.option.CommodityFutureOptionSecurity; import com.opengamma.financial.security.option.EquityIndexOptionSecurity; import com.opengamma.financial.security.option.EquityOptionSecurity; import com.opengamma.financial.security.option.FXBarrierOptionSecurity; import com.opengamma.financial.security.option.FXDigitalOptionSecurity; import com.opengamma.financial.security.option.FXOptionSecurity; import com.opengamma.financial.security.option.IRFutureOptionSecurity; import com.opengamma.financial.security.option.NonDeliverableFXDigitalOptionSecurity; import com.opengamma.financial.security.option.NonDeliverableFXOptionSecurity; import com.opengamma.financial.security.option.SwaptionSecurity; import com.opengamma.financial.security.swap.SwapSecurity; import com.opengamma.financial.tool.ToolContext; import com.opengamma.id.ExternalId; import com.opengamma.id.UniqueId; import com.opengamma.id.UniqueIdentifiable; import com.opengamma.integration.tool.IntegrationToolContext; import com.opengamma.master.config.ConfigDocument; import com.opengamma.master.config.ConfigMaster; import com.opengamma.master.config.ConfigMasterUtils; import com.opengamma.master.config.ConfigSearchRequest; import com.opengamma.master.config.impl.ConfigSearchIterator; import com.opengamma.master.security.SecurityDocument; import com.opengamma.master.security.SecurityMaster; import com.opengamma.master.security.SecuritySearchRequest; import com.opengamma.master.security.SecuritySearchSortOrder; import com.opengamma.master.security.impl.SecuritySearchIterator; import com.opengamma.scripts.Scriptable; import com.opengamma.util.OpenGammaClock; import com.opengamma.util.tuple.ObjectsPair; /** * Create volatility surfaces based on the instruments in security master. */ @Scriptable public class VolatilitySurfaceCreator extends AbstractTool<IntegrationToolContext> { /** the logger */ private static Logger s_logger = LoggerFactory.getLogger(VolatilitySurfaceCreator.class); /** bbg surface prefix */ private static final String BBG_SURFACE_PREFIX = "BBG_"; /** for ir bonds when using price */ private static final String PRICE = "PRICE_"; /** implied vol */ private static final String FIELD_NAME_VOL = MarketDataRequirementNames.IMPLIED_VOLATILITY; /** when getting price instead of vol */ private static final String FIELD_NAME_PRICE = MarketDataRequirementNames.MARKET_VALUE; /** wildcard search symbol */ private static final String WILDCARD_SEARCH = "*"; /** regexp to get strike from option ticker */ private static final String STRIKE_REGEXP = "[CP][ ]*((\\d)+(.\\d+)*)\\b"; //Track surfaces we create so we dont recreate them when multiple securities need them /** vol definitions we have created */ private final Set<String> _volDefinitionNames = new HashSet<String>(); /** vol specifications we have created */ private final Set<String> _volSpecificationNames = new HashSet<String>(); /** * Main method to run the tool. * * @param args command line arguments */ public static void main(String[] args) { // CSIGNORE new VolatilitySurfaceCreator().initAndRun(args, IntegrationToolContext.class); System.exit(0); } //------------------------------------------------------------------------- @Override protected void doRun() { ToolContext toolContext = getToolContext(); ConfigMaster configMaster = toolContext.getConfigMaster(); CommandLine commandLine = getCommandLine(); final String name = commandLine.getOptionValue("name", WILDCARD_SEARCH); final boolean dryRun = commandLine.hasOption("do-not-persist"); final boolean skipExisting = commandLine.hasOption("skip"); // if skipping existing surfaces get the list now if (skipExisting) { ConfigSearchRequest<VolatilitySurfaceDefinition<?, ?>> volDefinitionSearchRequest = new ConfigSearchRequest<VolatilitySurfaceDefinition<?, ?>>(); volDefinitionSearchRequest.setType(VolatilitySurfaceDefinition.class); // can't use name to restrict search as ticker symbol may not be same as underlying symbol (e.g. RUT vs RUY) volDefinitionSearchRequest.setName(WILDCARD_SEARCH); for (ConfigDocument doc : ConfigSearchIterator.iterable(configMaster, volDefinitionSearchRequest)) { _volDefinitionNames.add(doc.getName()); } ConfigSearchRequest<VolatilitySurfaceSpecification> volSpecSearchRequest = new ConfigSearchRequest<VolatilitySurfaceSpecification>(); volSpecSearchRequest.setType(VolatilitySurfaceSpecification.class); // can't use name to restrict search as ticker symbol may not be same as underlying symbol (e.g. RUT vs RUY) volSpecSearchRequest.setName(WILDCARD_SEARCH); for (ConfigDocument doc : ConfigSearchIterator.iterable(configMaster, volSpecSearchRequest)) { _volSpecificationNames.add(doc.getName()); } } createSurfaces(name, dryRun); } /** * Create surfaces for all (non-expired) securities * * @param name the pattern to match securities * @param dryRun set to true to not write to the database */ private void createSurfaces(String name, boolean dryRun) { ConfigMaster configMaster = getToolContext().getConfigMaster(); SecurityMaster securityMaster = getToolContext().getSecurityMaster(); ReferenceDataProvider bbgRefData = getToolContext().getBloombergReferenceDataProvider(); SecuritySearchRequest securityRequest = new SecuritySearchRequest(); securityRequest.setName(name); securityRequest.setSortOrder(SecuritySearchSortOrder.NAME_ASC); for (SecurityDocument doc : SecuritySearchIterator.iterable(securityMaster, securityRequest)) { FinancialSecurity security = (FinancialSecurity) doc.getSecurity(); try { security.accept(new VolSurfaceCreatorVisitor(configMaster, bbgRefData, _volSpecificationNames, _volDefinitionNames, dryRun)); } catch (Exception ex) { s_logger.error("Error processing " + security.getName() + ": " + ex.getLocalizedMessage()); continue; } } } /** * Visitor that creates surfaces for the security it visits */ private class VolSurfaceCreatorVisitor extends FinancialSecurityVisitorAdapter<Object> { /** the config master */ private final ConfigMaster _configMaster; /** the reference data provider */ private final ReferenceDataProvider _referenceDataProvider; /** known vol specifications */ private final Set<String> _knownVolSpecNames; /** known vol definitions */ private final Set<String> _knownVolDefNames; /** skip write to database */ private final boolean _dryRun; /** * @param configMaster the config master * @param referenceDataProvider the reference data provider * @param knownVolSpecNames surface specifications to skip * @param knownVolDefNames surface definitions to skip * @param dryRun if true skip write to the database */ VolSurfaceCreatorVisitor(final ConfigMaster configMaster, final ReferenceDataProvider referenceDataProvider, final Set<String> knownVolSpecNames, final Set<String> knownVolDefNames, final boolean dryRun) { _configMaster = configMaster; _referenceDataProvider = referenceDataProvider; _knownVolSpecNames = knownVolSpecNames; _knownVolDefNames = knownVolDefNames; _dryRun = dryRun; } @Override public Object visitBondFutureOptionSecurity(final BondFutureOptionSecurity security) { if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) { return null; } final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER); final BloombergTickerParserFutureOption tickerParser = new BloombergTickerParserBondFutureOption( ticker); //final String postfix = BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond(); String underlyingOptChainTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), tickerParser.getTypeName()); final String name = BBG_SURFACE_PREFIX + tickerParser.getSymbol() + "_" + security.getCurrency().getCode() + "_" + InstrumentTypeProperties.BOND_FUTURE_OPTION; if (!_knownVolSpecNames.contains(name)) { s_logger.info("Creating VolatilitySurfaceSpecification \"{}\"", name); final BloombergFutureOptionVolatilitySurfaceInstrumentProvider surfaceInstrumentProvider = new BloombergBondFutureOptionVolatilitySurfaceInstrumentProvider( tickerParser.getSymbol(), tickerParser.getTypeName(), FIELD_NAME_VOL, getSpot(underlyingOptChainTicker), security.getTradingExchange()); createVolatilitySpecification(security.getCurrency().getUniqueId(), name, surfaceInstrumentProvider); } createvolatilityDefinition(underlyingOptChainTicker, name, security.getCurrency().getUniqueId()); return null; } @Override public Object visitCommodityFutureOptionSecurity(final CommodityFutureOptionSecurity security) { if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) { return null; } final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER); final BloombergTickerParserFutureOption tickerParser = new BloombergTickerParserCommodityFutureOption( ticker); // final String postfix = BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond(); String underlyingOptChainTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), tickerParser.getTypeName()); final String name = BBG_SURFACE_PREFIX + tickerParser.getSymbol() + "_" + security.getCurrency().getCode() + "_" + InstrumentTypeProperties.COMMODITY_FUTURE_OPTION; if (!_knownVolSpecNames.contains(name)) { s_logger.info("Creating VolatilitySurfaceSpecification \"{}\"", name); final BloombergCommodityFutureOptionVolatilitySurfaceInstrumentProvider surfaceInstrumentProvider = new BloombergCommodityFutureOptionVolatilitySurfaceInstrumentProvider( tickerParser.getSymbol(), tickerParser.getTypeName(), FIELD_NAME_VOL, getSpot(underlyingOptChainTicker), security.getTradingExchange()); createVolatilitySpecification(security.getCurrency().getUniqueId(), name, surfaceInstrumentProvider); } createvolatilityDefinition(underlyingOptChainTicker, name, security.getCurrency().getUniqueId()); return null; } @Override public Object visitEquityIndexOptionSecurity(final EquityIndexOptionSecurity security) { if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) { return null; } final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER); final BloombergTickerParserEQIndexOption tickerParser = new BloombergTickerParserEQIndexOption(ticker); final String postfix = BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond(); String underlyingTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), postfix); final String name = BBG_SURFACE_PREFIX + underlyingTicker + "_" + InstrumentTypeProperties.EQUITY_OPTION; if (!_knownVolSpecNames.contains(name)) { s_logger.info("Creating VolatilitySurfaceSpecification \"{}\"", name); final BloombergEquityFutureOptionVolatilitySurfaceInstrumentProvider surfaceInstrumentProvider = new BloombergEquityFutureOptionVolatilitySurfaceInstrumentProvider( tickerParser.getSymbol(), postfix, FIELD_NAME_VOL, getSpot(underlyingTicker), security.getExchange()); createVolatilitySpecification( UniqueId.of(ExternalSchemes.BLOOMBERG_TICKER_WEAK.getName(), underlyingTicker), name, surfaceInstrumentProvider); } createvolatilityDefinition(underlyingTicker, name, UniqueId.of(ExternalSchemes.BLOOMBERG_TICKER_WEAK.getName(), underlyingTicker)); return null; } @Override public Object visitEquityOptionSecurity(final EquityOptionSecurity security) { if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) { return null; } final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER); final String postfix = BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond(); final String prefix = new BloombergTickerParserEQVanillaOption(ticker).getSymbol() + " " + security.getExchange(); String underlyingTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), postfix); final String name = BBG_SURFACE_PREFIX + prefix + "_" + InstrumentTypeProperties.EQUITY_OPTION; if (!_knownVolSpecNames.contains(name)) { s_logger.info("Creating VolatilitySurfaceSpecification \"{}\"", name); final BloombergEquityFutureOptionVolatilitySurfaceInstrumentProvider surfaceInstrumentProvider = new BloombergEquityFutureOptionVolatilitySurfaceInstrumentProvider( prefix, postfix, FIELD_NAME_VOL, getSpot(underlyingTicker), security.getExchange()); createVolatilitySpecification( UniqueId.of(ExternalSchemes.BLOOMBERG_TICKER_WEAK.getName(), underlyingTicker), name, surfaceInstrumentProvider); } createvolatilityDefinition(underlyingTicker, name, UniqueId.of(ExternalSchemes.BLOOMBERG_TICKER_WEAK.getName(), underlyingTicker)); return null; } @Override public Object visitIRFutureOptionSecurity(final IRFutureOptionSecurity security) { if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) { return null; } final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER); final BloombergTickerParserFutureOption tickerParser = new BloombergTickerParserIRFutureOption(ticker); // final String postfix = BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond(); String underlyingTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), tickerParser.getTypeName()); final String name = BBG_SURFACE_PREFIX + PRICE + tickerParser.getSymbol() + "_" + security.getCurrency().getCode() + "_" + InstrumentTypeProperties.IR_FUTURE_OPTION; if (!_knownVolSpecNames.contains(name)) { s_logger.info("Creating VolatilitySurfaceSpecification \"{}\"", name); final BloombergIRFutureOptionVolatilitySurfaceInstrumentProvider surfaceInstrumentProvider = new BloombergIRFutureOptionVolatilitySurfaceInstrumentProvider( tickerParser.getSymbol(), tickerParser.getTypeName(), FIELD_NAME_PRICE, getSpot(underlyingTicker), security.getExchange()); createVolatilitySpecification(security.getCurrency().getUniqueId(), name, surfaceInstrumentProvider, SurfaceAndCubePropertyNames.PRICE_QUOTE); } createvolatilityDefinition(underlyingTicker, name, security.getCurrency().getUniqueId()); return null; } // ------ FX securities handled by a different tool ------ @Override public Object visitFXOptionSecurity(final FXOptionSecurity security) { return null; } @Override public Object visitFXBarrierOptionSecurity(final FXBarrierOptionSecurity security) { return null; } @Override public Object visitFXDigitalOptionSecurity(final FXDigitalOptionSecurity security) { return null; } @Override public Object visitNonDeliverableFXOptionSecurity(final NonDeliverableFXOptionSecurity security) { return null; } @Override public Object visitNonDeliverableFXDigitalOptionSecurity( final NonDeliverableFXDigitalOptionSecurity security) { return null; } // ------ Non option securities ------- @Override public Object visitEquitySecurity(final EquitySecurity security) { return null; } @Override public Object visitEquityFutureSecurity(final EquityFutureSecurity security) { return null; } @Override public Object visitBondFutureSecurity(final BondFutureSecurity security) { return null; } @Override public Object visitInterestRateFutureSecurity(final InterestRateFutureSecurity security) { return null; } @Override public Object visitEnergyFutureSecurity(final EnergyFutureSecurity security) { return null; } @Override public Object visitMetalFutureSecurity(final MetalFutureSecurity security) { return null; } @Override public Object visitAgricultureFutureSecurity(final AgricultureFutureSecurity security) { return null; } @Override public Object visitGovernmentBondSecurity(final GovernmentBondSecurity security) { return null; } @Override public Object visitSwapSecurity(final SwapSecurity security) { return null; } @Override public Object visitSwaptionSecurity(final SwaptionSecurity security) { return null; } private void createvolatilityDefinition(final String underlyingTicker, final String name, final UniqueId target) { if (!_knownVolDefNames.contains(name)) { s_logger.info("Creating VolatilitySurfaceDefinition \"{}\"", name); final Set<ExternalId> options = BloombergDataUtils.getOptionChain(_referenceDataProvider, underlyingTicker); final ObjectsPair<ImmutableList<Double>, ImmutableList<Double>> axes = determineAxes(options); final VolatilitySurfaceDefinition<Double, Double> volSurfaceDefinition = new VolatilitySurfaceDefinition<Double, Double>( name, target, axes.getFirst().toArray(new Double[0]), axes.getSecond().toArray(new Double[0])); final ConfigItem<VolatilitySurfaceDefinition<Double, Double>> volDefinition = ConfigItem.of( volSurfaceDefinition, volSurfaceDefinition.getName(), VolatilitySurfaceDefinition.class); if (!_dryRun) { ConfigMasterUtils.storeByName(_configMaster, volDefinition); } _knownVolDefNames.add(name); } } private void createVolatilitySpecification(final UniqueIdentifiable target, final String name, final SurfaceInstrumentProvider<?, ?> surfaceInstrumentProvider, String quoteUnits) { final VolatilitySurfaceSpecification volSurfaceSpec = new VolatilitySurfaceSpecification(name, target, SurfaceAndCubeQuoteType.CALL_AND_PUT_STRIKE, quoteUnits, surfaceInstrumentProvider); final ConfigItem<VolatilitySurfaceSpecification> volSpecConfig = ConfigItem.of(volSurfaceSpec, volSurfaceSpec.getName(), VolatilitySurfaceSpecification.class); if (!_dryRun) { ConfigMasterUtils.storeByName(_configMaster, volSpecConfig); } _knownVolSpecNames.add(name); } private void createVolatilitySpecification(final UniqueIdentifiable target, final String name, final SurfaceInstrumentProvider<?, ?> surfaceInstrumentProvider) { createVolatilitySpecification(target, name, surfaceInstrumentProvider, SurfaceAndCubePropertyNames.VOLATILITY_QUOTE); } /** * From the available options determine axes for a volatility surface. * @param options the available options as given by OPT_CHAIN (must be tickers) * @return x and y axes */ private ObjectsPair<ImmutableList<Double>, ImmutableList<Double>> determineAxes( Collection<ExternalId> options) { Set<Double> strikes = new TreeSet<Double>(); Pattern strikePattern = Pattern.compile(STRIKE_REGEXP); for (ExternalId option : options) { String name = option.getValue(); Matcher matcher = strikePattern.matcher(name); if (!matcher.find()) { s_logger.error("Cant calculate strike for {}", name); continue; } strikes.add(Double.valueOf(matcher.group(1))); } if (strikes.isEmpty()) { throw new OpenGammaRuntimeException("Could not get any strikes"); } // assume all strikes exist for all exercise dates int numX = options.size() / strikes.size(); // Could call FUT_CHAIN to get list if OPT_CHAIN list is insufficient but just default to a reasonable value if (numX < 17) { numX = 17; } List<Double> xAxis = new ArrayList<Double>(); for (int i = 1; i < numX + 1; i++) { xAxis.add(Double.valueOf(i)); } return ObjectsPair.of(ImmutableList.copyOf(xAxis), ImmutableList.copyOf(strikes)); } private String getUnderlyingTicker(final String ticker, final ExternalId underlyingId, final String postfix) { if (underlyingId.isScheme(ExternalSchemes.BLOOMBERG_TICKER)) { return underlyingId.getValue(); } // underlying id is not a ticker - have to lookup //TODO: check if there is a better buid -> ticker lookup function String underlyingTicker = _referenceDataProvider .getReferenceData(Collections.singleton(ticker), Collections.singleton(BloombergConstants.FIELD_OPT_UNDL_TICKER)) .get(ticker).getString(BloombergConstants.FIELD_OPT_UNDL_TICKER) + " " + BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond(); if (!underlyingTicker.endsWith(postfix)) { underlyingTicker = underlyingTicker + " " + postfix; } return underlyingTicker; } private double getSpot(final String ticker) { //TODO: check if this is the correct field return _referenceDataProvider .getReferenceData(Collections.singleton(ticker), Collections.singleton(BloombergConstants.BBG_FIELD_LAST_PRICE)) .get(ticker).getDouble(BloombergConstants.BBG_FIELD_LAST_PRICE).doubleValue(); } } @Override protected Options createOptions(boolean mandatoryConfig) { Options options = super.createOptions(mandatoryConfig); options.addOption(createSearchOption()); options.addOption(createDoNotPersistOption()); options.addOption(createSkipExistingOption()); return options; } @SuppressWarnings("static-access") private Option createSearchOption() { return OptionBuilder.isRequired(false).hasArgs().withArgName("name search string") .withDescription("The name(s) you want to search for (globbing available) - default all") .withLongOpt("name").create("n"); } @SuppressWarnings("static-access") private Option createDoNotPersistOption() { return OptionBuilder.isRequired(false).hasArg(false) .withDescription("Simulate writing rather than actually writing to DB") .withLongOpt("do-not-persist").create("d"); } @SuppressWarnings("static-access") private Option createSkipExistingOption() { return OptionBuilder.isRequired(false).hasArg(false) .withDescription("Skip surfaces that already exist - do not overwrite").withLongOpt("skip") .create("s"); } @Override protected void usage(Options options) { HelpFormatter formatter = new HelpFormatter(); formatter.setWidth(120); formatter.printHelp("volatility-surface-creator.sh", options, true); } }