import org.threeten.bp.Clock; //导入依赖的package包/类
/**
 * Creates a {@link TimePickerDialog} instance.
 *
 * @param context   to retrieve the time format (12 or 24 hour)
 * @param localTime the initial localTime
 * @param listener  to listen for a localTime selection
 * @param clock     to retrieve the calendar from
 * @return a new instance of {@link TimePickerDialog}
 */
@NonNull
public static TimePickerDialog createDialog(@NonNull Context context, @Nullable LocalTime localTime,
                                            @Nullable Consumer<LocalTime> listener, @NonNull Clock clock) {
  TimePickerDialog.OnTimeSetListener dialogCallBack = (view, hourOfDay, minute, second) -> {
    LocalTime time = LocalTime.of(hourOfDay, minute, second);
    Optional.ofNullable(listener)
        .ifPresent(theListener -> theListener.accept(time));
  };

  localTime = Optional.ofNullable(localTime)
      .orElse(LocalTime.now(clock));
  TimePickerDialog timePickerDialog = TimePickerDialog.newInstance(
      dialogCallBack,
      localTime.getHour(),
      localTime.getMinute(),
      localTime.getSecond(),
      DateFormat.is24HourFormat(context)
  );
  timePickerDialog.dismissOnPause(true);
  return timePickerDialog;
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
/**
 * Creates a {@link DatePickerDialog} instance with the <code>localDate</code> selected.
 *
 * @param localDate the selected start localDate
 * @param listener to be triggered when the user selects a localDate
 * @param clock to get the current date
 * @return the {@link DatePickerDialog} created instance
 */
@NonNull
public static DatePickerDialog createDialog(@Nullable LocalDate localDate, @Nullable Consumer<LocalDate> listener,
                                            @NonNull Clock clock) {
  localDate = Optional.ofNullable(localDate)
      .orElse(LocalDate.now(clock));

  DatePickerDialog.OnDateSetListener dialogCallBack = (view, year, monthOfYear, dayOfMonth) -> {
    LocalDate date = LocalDate.of(year, monthOfYear + 1, dayOfMonth);
    Optional.ofNullable(listener)
        .ifPresent(theListener -> theListener.accept(date));
  };

  DatePickerDialog datePickerDialog = DatePickerDialog.newInstance(
      dialogCallBack,
      localDate.getYear(),
      localDate.getMonthValue() - 1,
      localDate.getDayOfMonth()
  );
  datePickerDialog.dismissOnPause(true);
  return datePickerDialog;
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final ZonedDateTime now = ZonedDateTime.now(Clock.systemUTC());
  final EquityOptionSecurity option = (EquityOptionSecurity) target.getSecurity();
  final ValueRequirement underlyingPriceRequirement = getPriceRequirement(option.getUnderlyingId());
  final ValueRequirement discountCurveDataRequirement = getDiscountCurveMarketDataRequirement(option.getCurrency());
  final YieldAndDiscountCurve discountCurve = (YieldAndDiscountCurve) inputs.getValue(discountCurveDataRequirement);
  final double spotPrice = (Double) inputs.getValue(underlyingPriceRequirement);
  final Expiry expiry = option.getExpiry();
  final double t = DateUtils.getDifferenceInYears(now, expiry.getExpiry());
  final double b = discountCurve.getInterestRate(t); // TODO cost-of-carry model
  @SuppressWarnings("unused")
  final StandardOptionDataBundle data = new StandardOptionDataBundle(discountCurve, b, null, spotPrice, now);
  // TODO Map<OptionDefinition, Double> of options that will be used to form surface
  final VolatilitySurface surface = null; // TODO
  final ValueSpecification specification = createResultSpecification(target);
  final ComputedValue result = new ComputedValue(specification, surface);
  return Collections.singleton(result);
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final ValueRequirement desiredValue = desiredValues.iterator().next();
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final HistoricalTimeSeriesBundle timeSeries = HistoricalTimeSeriesFunctionUtils.getHistoricalTimeSeriesInputs(executionContext, inputs);
  final InstrumentDefinition<InstrumentDerivative> irFutureOptionDefinition = (InstrumentDefinition<InstrumentDerivative>) getConverter(executionContext).convert(target.getTrade());
  final String surfaceName = desiredValue.getConstraint(ValuePropertyNames.SURFACE);
  final String curveCalculationConfigName = desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
  final MultiCurveCalculationConfig curveCalculationConfig = _curveCalculationConfigSource.getConfig(curveCalculationConfigName);
  if (curveCalculationConfig == null) {
    throw new OpenGammaRuntimeException("Could not find curve calculation configuration named " + curveCalculationConfigName);
  }
  final String[] curveNames = curveCalculationConfig.getYieldCurveNames();
  final YieldCurveBundle curves = YieldCurveFunctionUtils.getYieldCurves(inputs, curveCalculationConfig);
  final InstrumentDerivative irFutureOption = _dataConverter.convert(target.getTrade().getSecurity(), irFutureOptionDefinition, now, curveNames, timeSeries);
  final double price = irFutureOption.accept(new MyDerivativeVisitor(target, inputs, curves));
  final ValueSpecification valueSpecification = new ValueSpecification(ValueRequirementNames.PRESENT_VALUE, target.toSpecification(), createValueProperties()
      .with(ValuePropertyNames.CURRENCY, FinancialSecurityUtils.getCurrency(target.getTrade().getSecurity()).getCode())
      .with(ValuePropertyNames.CURVE_CALCULATION_CONFIG, curveCalculationConfigName).with(ValuePropertyNames.SURFACE, surfaceName).with(ValuePropertyNames.SMILE_FITTING_METHOD, "Heston")
      .with(ValuePropertyNames.CALCULATION_METHOD, "Fourier").get());
  return Sets.newHashSet(new ComputedValue(valueSpecification, price));
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
protected SkewKurtosisOptionDataBundle getDataBundle(final Clock relevantTime, final EquityOptionSecurity option, final FunctionInputs inputs) {
  final StandardOptionDataBundle standardData = super.getDataBundle(relevantTime, option, inputs);
  final UniqueId uid = option.getUniqueId();
  final Object skewObject = inputs.getValue(ValueRequirementNames.SKEW);
  if (skewObject == null) {
    throw new NullPointerException("Could not get skew");
  }
  final Object kurtosisObject = inputs.getValue(ValueRequirementNames.PEARSON_KURTOSIS);
  if (kurtosisObject == null) {
    throw new NullPointerException("Could not get Pearson kurtosis");
  }
  final double skew = (Double) skewObject;
  final double kurtosis = (Double) kurtosisObject;
  return new SkewKurtosisOptionDataBundle(standardData, skew, kurtosis);
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
protected StandardOptionDataBundle getDataBundle(final Clock relevantTime, final EquityOptionSecurity option, final FunctionInputs inputs) {
  //REVIEW yomi 03-06-2011 Elaine needs to confirm what needs to go here because we cannot deal with FXOptionSecurity here
  /*
  final ZonedDateTime now = relevantTime.zonedDateTime();
  final FXOptionSecurity fxOption = (FXOptionSecurity) option;
  final Security underlying = secMaster.getSecurity(ExternalIdBundle.of(option.getUnderlyingIdentifier())); //TODO make sure spot FX rate is right way up
  final Double spotAsObject = (Double) inputs.getValue(getUnderlyingMarketDataRequirement(underlying.getUniqueId()));
  if (spotAsObject == null) {
    throw new NullPointerException("No spot value for underlying instrument.");
  }
  final double spot = spotAsObject;
  final VolatilitySurface volatilitySurface = (VolatilitySurface) inputs.getValue(getVolatilitySurfaceMarketDataRequirement(option));
  //TODO check call / put are actually the right way around
  final YieldAndDiscountCurve domesticCurve = (YieldAndDiscountCurve) inputs.getValue(getYieldCurveMarketDataRequirement(fxOption.getCallCurrency().getUniqueId()));
  final YieldAndDiscountCurve foreignCurve = (YieldAndDiscountCurve) inputs.getValue(getYieldCurveMarketDataRequirement(fxOption.getPutCurrency().getUniqueId()));
  final Expiry expiry = option.getExpiry();
  final double t = DateUtil.getDifferenceInYears(now, expiry.getExpiry().toInstant());
  final double b = foreignCurve.getInterestRate(t); //TODO not great but needs an analytics refactor
  return new StandardOptionDataBundle(domesticCurve, b, volatilitySurface, spot, now);
   */
  throw new UnsupportedOperationException();
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final HistoricalTimeSeriesBundle timeSeries = HistoricalTimeSeriesFunctionUtils.getHistoricalTimeSeriesInputs(executionContext, inputs);
  final Trade trade = target.getTrade();
  final ValueRequirement desiredValue = desiredValues.iterator().next();
  final String curveCalculationConfigName = desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
  final MultiCurveCalculationConfig curveCalculationConfig = _curveConfigSource.getConfig(curveCalculationConfigName);
  if (curveCalculationConfig == null) {
    throw new OpenGammaRuntimeException("Could not find curve calculation configuration named " + curveCalculationConfigName);
  }
  final String currency = FinancialSecurityUtils.getCurrency(trade.getSecurity()).getCode();
  final String[] curveNames = curveCalculationConfig.getYieldCurveNames();
  final String[] yieldCurveNames = curveNames.length == 1 ? new String[] {curveNames[0], curveNames[0] } : curveNames;
  final String[] fullYieldCurveNames = new String[yieldCurveNames.length];
  for (int i = 0; i < yieldCurveNames.length; i++) {
    fullYieldCurveNames[i] = yieldCurveNames[i] + "_" + currency;
  }
  final YieldCurveBundle data = YieldCurveFunctionUtils.getAllYieldCurves(inputs, curveCalculationConfig, _curveConfigSource);
  final InstrumentDefinition<InstrumentDerivative> irFutureDefinition = _converter.convert(trade);
  final InstrumentDerivative irFuture = _dataConverter.convert(trade.getSecurity(), irFutureDefinition, now, fullYieldCurveNames, timeSeries);
  final ValueSpecification spec = getSpecification(target, curveCalculationConfigName);
  return getResults(irFuture, data, spec);
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public void getValues(final Collection<PayoffStyle> values) {
  values.add(new AssetOrNothingPayoffStyle());
  values.add(new AsymmetricPoweredPayoffStyle(s_random.nextDouble()));
  values.add(new BarrierPayoffStyle());
  values.add(new CappedPoweredPayoffStyle(s_random.nextDouble(), s_random.nextDouble()));
  values.add(new CashOrNothingPayoffStyle(s_random.nextDouble()));
  values.add(new FadeInPayoffStyle(s_random.nextDouble(), s_random.nextDouble()));
  values.add(new FixedStrikeLookbackPayoffStyle());
  values.add(new FloatingStrikeLookbackPayoffStyle());
  values.add(new GapPayoffStyle(s_random.nextDouble()));
  values.add(new PoweredPayoffStyle(s_random.nextDouble()));
  values.add(new SupersharePayoffStyle(s_random.nextDouble(), s_random.nextDouble()));
  values.add(new VanillaPayoffStyle());
  values.add(new ExtremeSpreadPayoffStyle(ZonedDateTime.now().withNano(0), s_random.nextBoolean()));
  values.add(new SimpleChooserPayoffStyle(ZonedDateTime.now().withNano(0), s_random.nextDouble(),
      new Expiry(ZonedDateTime.now(Clock.systemDefaultZone()), ExpiryAccuracy.MONTH_YEAR)));
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
protected void runOneCycle() {
  s_logger.debug("queueSize {} ", _writerQueue.size());
  for (String security : _securities) {
    int msgSize = _messageSizeGenerator.nextInt(MAX_MESSAGE_SIZE);
    for (int i = 0; i < msgSize; i++) {
      try {
        MutableFudgeMsg msg = getRandomMessage();
        Instant instant = Clock.systemUTC().instant();
        long epochMillis = instant.toEpochMilli();
        msg.add(RECEIVED_TS_KEY, epochMillis);
        msg.add(SECURITY_KEY, security);
        s_logger.debug("generating {}", msg);
        _writerQueue.put(msg);
      } catch (InterruptedException e) {
        Thread.interrupted();
        s_logger.warn("interrupted exception while putting ticks message on queue");
      }
    }
  }
  
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Test(expectedExceptions = IllegalArgumentException.class)
public void test_ReplaceVersion_noUid() {
  Clock origClock = _cfgMaster.getClock();
  try {
    Instant now = Instant.now();

    ObjectId baseOid = setupTestData(now);
    _cfgMaster.setClock(Clock.fixed(now.plus(2, HOURS), ZoneOffset.UTC));


    List<ConfigDocument> replacement = newArrayList();
    for (int i = 0; i <= 2; i++) {
      String val = "replace_" + i;
      ConfigDocument doc = new ConfigDocument(ConfigItem.of(val));
      doc.setVersionFromInstant(now.plus(1, MINUTES).plus(i * 20, SECONDS));
      replacement.add(doc);
    }

    _cfgMaster.replaceVersion(baseOid.atVersion("no such uid"), replacement);
  } finally {
    _cfgMaster.setClock(origClock);
  }
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Provides
@Singleton
public Clock provideClock() {
  Instant instant = Instant.parse("2016-05-06T10:15:30.00Z");
  ZoneId zoneId = ZoneId.of(DEFAULT_TIME_ZONE_STRING);
  return Clock.fixed(instant, zoneId);
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
/**
 * Retrieves a {@link Calendar} instance from the {@code clock}.
 *
 * @param clock to be used to retrieve the {@link Calendar} instance.
 * @return a new {@link Calendar} instance representing the clock's time.
 */
@NonNull
public static Calendar getCalendarFromClock(Clock clock) {
  Calendar calendar = Calendar.getInstance();
  calendar.setTimeInMillis(clock.millis());
  return calendar;
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final Object volatilitySurfaceDataObject = inputs.getValue(_requirement);
  if (volatilitySurfaceDataObject == null) {
    throw new OpenGammaRuntimeException("Could not get " + _requirement);
  }
  @SuppressWarnings("unchecked")
  final VolatilitySurfaceData<LocalDate, Double> volatilitySurfaceData = (VolatilitySurfaceData<LocalDate, Double>) volatilitySurfaceDataObject;
  final int n = volatilitySurfaceData.getXs().length;
  final int m = volatilitySurfaceData.getYs().length;
  final DoubleArrayList t = new DoubleArrayList();
  final DoubleArrayList k = new DoubleArrayList();
  final DoubleArrayList sigma = new DoubleArrayList();
  final LocalDate[] xDates = volatilitySurfaceData.getXs();
  final Double[] y = volatilitySurfaceData.getYs();
  for (int i = 0; i < n; i++) {
    final Double time = DateUtils.getDifferenceInYears(now.toLocalDate(), xDates[i]);
    for (int j = 0; j < m; j++) {
      final Double strike = y[j];
      final Double vol = volatilitySurfaceData.getVolatility(xDates[i], y[j]);
      if (time != null && strike != null && vol != null) {
        t.add(time);
        k.add(strike);
        sigma.add(vol);
      }
    }
  }
  final Surface<Double, Double, Double> surface = InterpolatedDoublesSurface.from(t.toDoubleArray(), k.toDoubleArray(), sigma.toDoubleArray(), _interpolator);
  final VolatilitySurface volatilitySurface = new VolatilitySurface(surface);
  return Collections.singleton(new ComputedValue(_result, volatilitySurface));
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
  final ValueRequirement desiredValue = desiredValues.iterator().next();
  final double theta = Double.parseDouble(desiredValue.getConstraint(PROPERTY_THETA));
  final int nTimeSteps = Integer.parseInt(desiredValue.getConstraint(PROPERTY_NUMBER_TIME_STEPS));
  final int nSpaceSteps = Integer.parseInt(desiredValue.getConstraint(PROPERTY_NUMBER_SPACE_STEPS));
  final double timeStepBunching = Double.parseDouble(desiredValue.getConstraint(PROPERTY_TIME_STEP_BUNCHING));
  final double spaceStepBunching = Double.parseDouble(desiredValue.getConstraint(PROPERTY_SPACE_STEPS_BUNCHING));
  final double maxProxyDelta = Double.parseDouble(desiredValue.getConstraint(PROPERTY_MAX_PROXY_DELTA));
  final double centreMoneyness = Double.parseDouble(desiredValue.getConstraint(PROPERTY_CENTRE_MONEYNESS));
  final String interpolatorName = desiredValue.getConstraint(PROPERTY_SPACE_DIRECTION_INTERPOLATOR);
  final Interpolator1D interpolator = Interpolator1DFactory.getInterpolator(interpolatorName);
  final PDELocalVolatilityCalculator<?> pdeCalculator =
      getPDECalculator(new LocalVolatilityForwardPDECalculator(theta, nTimeSteps, nSpaceSteps, timeStepBunching, spaceStepBunching, maxProxyDelta, centreMoneyness), interpolator);
  final Object localVolatilityObject = inputs.getValue(ValueRequirementNames.LOCAL_VOLATILITY_SURFACE);
  if (localVolatilityObject == null) {
    throw new OpenGammaRuntimeException("Could not get local volatility surface");
  }
  final Object forwardCurveObject = inputs.getValue(ValueRequirementNames.FORWARD_CURVE);
  if (forwardCurveObject == null) {
    throw new OpenGammaRuntimeException("Could not get forward curve");
  }
  final Object discountingCurveObject = inputs.getValue(ValueRequirementNames.YIELD_CURVE);
  if (discountingCurveObject == null) {
    throw new OpenGammaRuntimeException("Could not get discounting curve");
  }
  final LocalVolatilitySurfaceMoneyness localVolatility = (LocalVolatilitySurfaceMoneyness) localVolatilityObject;
  final ForwardCurve forwardCurve = (ForwardCurve) forwardCurveObject;
  final EuropeanVanillaOption option = getOption(security, now);
  final YieldAndDiscountCurve discountingCurve = (YieldAndDiscountCurve) discountingCurveObject;
  final Object result = getResult(pdeCalculator, localVolatility, forwardCurve, option, discountingCurve);
  final ValueProperties properties = getResultProperties(desiredValue);
  final ValueSpecification spec = new ValueSpecification(getRequirementName(), target.toSpecification(), properties);
  return Collections.singleton(new ComputedValue(spec, result));
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
  final ValueRequirement desiredValue = desiredValues.iterator().next();
  final double theta = Double.parseDouble(desiredValue.getConstraint(PROPERTY_THETA));
  final int nTimeSteps = Integer.parseInt(desiredValue.getConstraint(PROPERTY_NUMBER_TIME_STEPS));
  final int nSpaceSteps = Integer.parseInt(desiredValue.getConstraint(PROPERTY_NUMBER_SPACE_STEPS));
  final double timeStepBunching = Double.parseDouble(desiredValue.getConstraint(PROPERTY_TIME_STEP_BUNCHING));
  final double spaceStepBunching = Double.parseDouble(desiredValue.getConstraint(PROPERTY_SPACE_STEPS_BUNCHING));
  final double maxMoneyness = Double.parseDouble(desiredValue.getConstraint(PROPERTY_MAX_MONEYNESS));
  final String interpolatorName = desiredValue.getConstraint(PROPERTY_SPACE_DIRECTION_INTERPOLATOR);
  final Interpolator1D interpolator = Interpolator1DFactory.getInterpolator(interpolatorName);
  final PDELocalVolatilityCalculator<?> pdeCalculator =
      getPDECalculator(new LocalVolatilityBackwardPDECalculator(theta, nTimeSteps, nSpaceSteps, timeStepBunching, spaceStepBunching, maxMoneyness), interpolator);
  final Object localVolatilityObject = inputs.getValue(getVolatilitySurfaceRequirement(target, desiredValue));
  if (localVolatilityObject == null) {
    throw new OpenGammaRuntimeException("Could not get local volatility surface");
  }
  final Object forwardCurveObject = inputs.getValue(getForwardCurveRequirement(target, desiredValue));
  if (forwardCurveObject == null) {
    throw new OpenGammaRuntimeException("Could not get forward curve");
  }
  final Object discountingCurveObject = inputs.getValue(getDiscountingCurveRequirement(target, desiredValue));
  if (discountingCurveObject == null) {
    throw new OpenGammaRuntimeException("Could not get discounting curve");
  }
  final LocalVolatilitySurfaceMoneyness localVolatility = (LocalVolatilitySurfaceMoneyness) localVolatilityObject;
  final ForwardCurve forwardCurve = (ForwardCurve) forwardCurveObject;
  final EuropeanVanillaOption option = getOption(security, now);
  final YieldAndDiscountCurve discountingCurve = (YieldAndDiscountCurve) discountingCurveObject;
  final Object result = getResult(pdeCalculator, localVolatility, forwardCurve, option, discountingCurve);
  final ValueProperties properties = getResultProperties(desiredValue);
  final ValueSpecification spec = new ValueSpecification(getRequirementName(), target.toSpecification(), properties);
  return Collections.singleton(new ComputedValue(spec, result));
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final SecuritySource securitySource = OpenGammaExecutionContext.getSecuritySource(executionContext);
  final SwaptionSecurity security = (SwaptionSecurity) target.getSecurity();
  final ValueRequirement desiredValue = desiredValues.iterator().next();
  final Currency currency = FinancialSecurityUtils.getCurrency(security);
  final String surfaceName = desiredValue.getConstraint(ValuePropertyNames.SURFACE);
  final String curveCalculationConfigName = desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
  final MultiCurveCalculationConfig curveCalculationConfig = _curveCalculationConfigSource.getConfig(curveCalculationConfigName);
  if (curveCalculationConfig == null) {
    throw new OpenGammaRuntimeException("Could not find curve calculation configuration named " + curveCalculationConfigName);
  }
  String[] curveNames = curveCalculationConfig.getYieldCurveNames();
  if (curveNames.length == 1) {
    curveNames = new String[] {curveNames[0], curveNames[0] };
  }
  final String[] fullCurveNames = new String[curveNames.length];
  for (int i = 0; i < curveNames.length; i++) {
    fullCurveNames[i] = curveNames[i] + "_" + currency.getCode();
  }
  final YieldCurveBundle curves = YieldCurveFunctionUtils.getYieldCurves(inputs, curveCalculationConfig);
  final Object volatilitySurfaceObject = inputs.getValue(getVolatilityRequirement(surfaceName, currency));
  if (volatilitySurfaceObject == null) {
    throw new OpenGammaRuntimeException("Could not get volatility surface");
  }
  final VolatilitySurface volatilitySurface = (VolatilitySurface) volatilitySurfaceObject;
  if (!(volatilitySurface.getSurface() instanceof InterpolatedDoublesSurface)) {
    throw new OpenGammaRuntimeException("Expecting an InterpolatedDoublesSurface; got " + volatilitySurface.getSurface().getClass());
  }
  final InstrumentDefinition<?> definition = security.accept(_visitor);
  final HistoricalTimeSeriesBundle timeSeries = HistoricalTimeSeriesFunctionUtils.getHistoricalTimeSeriesInputs(executionContext, inputs);
  final InstrumentDerivative swaption = _definitionConverter.convert(security, definition, now, fullCurveNames, timeSeries);
  final ValueProperties properties = getResultProperties(currency.getCode(), curveCalculationConfigName, surfaceName);
  final ValueSpecification spec = new ValueSpecification(_valueRequirementName, target.toSpecification(), properties);
  final BlackFlatSwaptionParameters parameters = new BlackFlatSwaptionParameters(volatilitySurface.getSurface(), SwaptionUtils.getSwapGenerator(security, definition, securitySource));
  final YieldCurveWithBlackSwaptionBundle data = new YieldCurveWithBlackSwaptionBundle(parameters, curves);
  return getResult(swaption, data, spec);
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target,
    final Set<ValueRequirement> desiredValues) throws AsynchronousExecution {
  final FXMatrix fxMatrix = (FXMatrix) inputs.getValue(ValueRequirementNames.FX_MATRIX);
  final T knownData = getKnownData(inputs);
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);

  //To ensure that the ValueProperties matches the one created in getBundleProperties, the currencies are extracted
  //from the fx matrix and given to the ValueProperties if they exist. This change results in the base classes
  //needing to remove the curve sensitivity currencies from the curve ValueProperties
  Set<String> currencies = new HashSet();
  for (Currency currency : fxMatrix.getCurrencies().keySet()) {
    currencies.add(currency.toString());
  }
  String[] sensitivityCurrencies = currencies.toArray(new String[currencies.size()]);
  final ValueProperties.Builder propertiesBuilder = desiredValues.iterator().next().getConstraints().copy()
      .withoutAny(CURVE)
      .with(CURVE, Arrays.asList(_curveNames));
  if (!currencies.isEmpty()) {
    propertiesBuilder.with(CURVE_SENSITIVITY_CURRENCY, sensitivityCurrencies);
  }
  ValueProperties properties  = propertiesBuilder.get();

  final double absoluteTolerance = Double.parseDouble(Iterables.getOnlyElement(properties.getValues(PROPERTY_ROOT_FINDER_ABSOLUTE_TOLERANCE)));
  final double relativeTolerance = Double.parseDouble(Iterables.getOnlyElement(properties.getValues(PROPERTY_ROOT_FINDER_RELATIVE_TOLERANCE)));
  final int maxIterations = Integer.parseInt(Iterables.getOnlyElement(properties.getValues(PROPERTY_ROOT_FINDER_MAX_ITERATIONS)));
  final U builder = getBuilder(absoluteTolerance, relativeTolerance, maxIterations);
  final Pair<T, CurveBuildingBlockBundle> pair = getCurves(inputs, now, builder, knownData, executionContext, fxMatrix);
  final ValueSpecification bundleSpec = new ValueSpecification(CURVE_BUNDLE, ComputationTargetSpecification.NULL, properties);
  final ValueSpecification jacobianSpec = new ValueSpecification(JACOBIAN_BUNDLE, ComputationTargetSpecification.NULL, properties);
  return getResults(bundleSpec, jacobianSpec, properties, pair);
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final HistoricalTimeSeriesBundle timeSeries = HistoricalTimeSeriesFunctionUtils.getHistoricalTimeSeriesInputs(executionContext, inputs);
  final Trade trade = target.getTrade();
  final IRFutureOptionSecurity security = (IRFutureOptionSecurity) trade.getSecurity();
  final ValueRequirement desiredValue = desiredValues.iterator().next();
  final Currency currency = FinancialSecurityUtils.getCurrency(security);
  final String surfaceName = desiredValue.getConstraint(ValuePropertyNames.SURFACE);
  final String surfaceNameWithPrefix = surfaceName + "_" + IRFutureOptionFunctionHelper.getFutureOptionPrefix(target); // Done to enable standard and midcurve options to share the same default name
  final String curveCalculationConfigName = desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
  final MultiCurveCalculationConfig curveCalculationConfig = _curveCalculationConfigSource.getConfig(curveCalculationConfigName);
  if (curveCalculationConfig == null) {
    throw new OpenGammaRuntimeException("Could not find curve calculation configuration named " + curveCalculationConfigName);
  }
  final String[] curveNames = curveCalculationConfig.getYieldCurveNames();
  final String[] fullCurveNames = new String[Math.max(2, curveNames.length)];
  for (int i = 0; i < curveNames.length; i++) {
    fullCurveNames[i] = curveNames[i] + "_" + currency.getCode();
  }
  if (curveNames.length == 1) { // MultiCurveCalculationConfig contains just a single curve for discounting and forwarding
    fullCurveNames[1] = fullCurveNames[0];
  }
  final YieldCurveBundle curves = YieldCurveFunctionUtils.getAllYieldCurves(inputs, curveCalculationConfig, _curveCalculationConfigSource);
  final Object volatilitySurfaceObject = inputs.getValue(getVolatilityRequirement(surfaceNameWithPrefix, currency));
  if (volatilitySurfaceObject == null) {
    throw new OpenGammaRuntimeException("Could not get volatility surface");
  }
  final VolatilitySurface volatilitySurface = (VolatilitySurface) volatilitySurfaceObject;
  if (!(volatilitySurface.getSurface() instanceof InterpolatedDoublesSurface)) {
    throw new OpenGammaRuntimeException("Expecting an InterpolatedDoublesSurface; got " + volatilitySurface.getSurface().getClass());
  }
  final InstrumentDefinition<?> irFutureOptionDefinition = getConverter(executionContext).convert(trade);
  final InstrumentDerivative irFutureOption = _dataConverter.convert(security, irFutureOptionDefinition, now, fullCurveNames, timeSeries);
  final ValueSpecification spec = new ValueSpecification(_valueRequirementName, target.toSpecification(), desiredValue.getConstraints());
  final YieldCurveWithBlackCubeBundle data = new YieldCurveWithBlackCubeBundle(volatilitySurface.getSurface(), curves);
  return getResult(irFutureOption, data, spec, desiredValues);
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, final Set<ValueRequirement> desiredValues) {
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final HistoricalTimeSeriesBundle timeSeries = HistoricalTimeSeriesFunctionUtils.getHistoricalTimeSeriesInputs(executionContext, inputs);
  final Trade trade = target.getTrade();
  final IRFutureOptionSecurity security = (IRFutureOptionSecurity) trade.getSecurity();
  final ValueRequirement desiredValue = desiredValues.iterator().next();
  final Currency currency = FinancialSecurityUtils.getCurrency(security);
  final String curveName = desiredValue.getConstraint(ValuePropertyNames.CURVE);
  final String surfaceName = desiredValue.getConstraint(ValuePropertyNames.SURFACE);
  // To enable standard and midcurve options to share the same default name
  final String surfaceNameWithPrefix = surfaceName + "_" + IRFutureOptionFunctionHelper.getFutureOptionPrefix(target);
  final String curveCalculationConfigName = desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
  final MultiCurveCalculationConfig curveCalculationConfig = _curveCalculationConfigSource.getConfig(curveCalculationConfigName);
  if (curveCalculationConfig == null) {
    throw new OpenGammaRuntimeException("Could not find curve calculation configuration named " + curveCalculationConfigName);
  }
  final String[] curveNames = curveCalculationConfig.getYieldCurveNames();
  final String[] fullCurveNames = new String[curveNames.length];
  for (int i = 0; i < curveNames.length; i++) {
    fullCurveNames[i] = curveNames[i] + "_" + currency.getCode();
  }
  final YieldCurveBundle curves = YieldCurveFunctionUtils.getAllYieldCurves(inputs, curveCalculationConfig, _curveCalculationConfigSource);
  final Object volatilitySurfaceObject = inputs.getValue(getVolatilityRequirement(surfaceNameWithPrefix, currency));
  if (volatilitySurfaceObject == null) {
    throw new OpenGammaRuntimeException("Could not get volatility surface");
  }
  final VolatilitySurface volatilitySurface = (VolatilitySurface) volatilitySurfaceObject;
  if (!(volatilitySurface.getSurface() instanceof InterpolatedDoublesSurface)) {
    throw new OpenGammaRuntimeException("Expecting an InterpolatedDoublesSurface; got " + volatilitySurface.getSurface().getClass());
  }
  final InstrumentDefinition<?> irFutureOptionDefinition = getConverter(executionContext).convert(trade);
  final InstrumentDerivative irFutureOption = _dataConverter.convert(security, irFutureOptionDefinition, now, fullCurveNames, timeSeries);
  final ValueProperties properties = getResultProperties(currency.getCode(), curveCalculationConfigName, surfaceName, curveName);
  final ValueSpecification spec = new ValueSpecification(_valueRequirementName, target.toSpecification(), properties);
  final YieldCurveWithBlackCubeBundle data = new YieldCurveWithBlackCubeBundle(volatilitySurface.getSurface(), curves);
  return getResult(irFutureOption, data, curveName, spec, security);
}
 

import org.threeten.bp.Clock; //导入依赖的package包/类
@Override
public Set<ComputedValue> execute(final FunctionExecutionContext executionContext, final FunctionInputs inputs, final ComputationTarget target, 
    final Set<ValueRequirement> desiredValues)
  throws AsynchronousExecution {
  final ConventionBundleSource conventionSource = OpenGammaExecutionContext.getConventionBundleSource(executionContext);
  final Clock snapshotClock = executionContext.getValuationClock();
  final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
  final HistoricalTimeSeriesBundle timeSeries = HistoricalTimeSeriesFunctionUtils.getHistoricalTimeSeriesInputs(executionContext, inputs);
  final Trade trade = target.getTrade();
  final ValueRequirement desiredValue = desiredValues.iterator().next();
  final String curveCalculationConfigName = desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
  final MultiCurveCalculationConfig curveCalculationConfig = _curveCalculationConfigSource.getConfig(curveCalculationConfigName);
  if (curveCalculationConfig == null) {
    throw new OpenGammaRuntimeException("Could not find curve calculation configuration named " + curveCalculationConfigName);
  }
  final String[] curveNames = curveCalculationConfig.getYieldCurveNames();
  final YieldCurveBundle curves = YieldCur