/**
* Copyright (C) 2014 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.sesame.fra;
import java.math.BigDecimal;
import java.util.Map;
import java.util.Set;
import org.threeten.bp.LocalDate;
import org.threeten.bp.OffsetTime;
import com.opengamma.core.position.Counterparty;
import com.opengamma.core.position.Trade;
import com.opengamma.core.position.impl.SimpleCounterparty;
import com.opengamma.core.position.impl.SimpleTrade;
import com.opengamma.financial.analytics.conversion.FRASecurityConverter;
import com.opengamma.financial.analytics.conversion.FixedIncomeConverterDataProvider;
import com.opengamma.financial.analytics.timeseries.HistoricalTimeSeriesBundle;
import com.opengamma.financial.security.fra.FRASecurity;
import com.opengamma.financial.security.fra.ForwardRateAgreementSecurity;
import com.opengamma.id.ExternalId;
import com.opengamma.sesame.CurveLabellingFn;
import com.opengamma.sesame.CurveMatrixLabeller;
import com.opengamma.sesame.DiscountingMulticurveCombinerFn;
import com.opengamma.sesame.Environment;
import com.opengamma.sesame.FixingsFn;
import com.opengamma.sesame.MulticurveBundle;
import com.opengamma.sesame.trade.ForwardRateAgreementTrade;
import com.opengamma.sesame.trade.FraTrade;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.result.Result;
/**
* Factory class for creating a calculator for a discounting FRA.
*/
public class DiscountingFRACalculatorFactory implements FRACalculatorFactory {
/**
* Converter for a FRA.
*/
private final FRASecurityConverter _fraConverter;
/**
* Definition to derivative converter.
*/
private final FixedIncomeConverterDataProvider _fixedIncomeConverterDataProvider;
/**
* Function used to generate a combined multicurve bundle suitable
* for use with a particular security.
*/
private final DiscountingMulticurveCombinerFn _discountingMulticurveCombinerFn;
/**
* HTS function for fixings.
*/
private final FixingsFn _htsFn;
/**
* Curve labelling function.
*/
private final CurveLabellingFn _curveLabellingFn;
/**
* Creates the factory.
*
* @param fraConverter for transforming a fra into its InstrumentDefinition form, not null
* @param fixedIncomeConverterDataProvider for transforming the InstrumentDefinition into Derivative, not null
* @param discountingMulticurveCombinerFn function for creating multicurve bundles, not null
* @param htsFn Function to get the fixing for a security, not null
* @param curveLabellingFn the curve labelling function, not null.
*/
public DiscountingFRACalculatorFactory(FRASecurityConverter fraConverter,
FixedIncomeConverterDataProvider fixedIncomeConverterDataProvider,
DiscountingMulticurveCombinerFn discountingMulticurveCombinerFn,
FixingsFn htsFn,
CurveLabellingFn curveLabellingFn) {
_fraConverter = ArgumentChecker.notNull(fraConverter, "fraConverter");
_fixedIncomeConverterDataProvider =
ArgumentChecker.notNull(fixedIncomeConverterDataProvider, "fixedIncomeConverterDataProvider");
_discountingMulticurveCombinerFn =
ArgumentChecker.notNull(discountingMulticurveCombinerFn, "discountingMulticurveCombinerFn");
_htsFn = ArgumentChecker.notNull(htsFn, "htsFn");
_curveLabellingFn = ArgumentChecker.notNull(curveLabellingFn, "curveLabellingFn");
}
@Override
public Result<FRACalculator> createCalculator(Environment env, FRASecurity security) {
Trade trade = new SimpleTrade(security,
BigDecimal.ONE,
new SimpleCounterparty(ExternalId.of(Counterparty.DEFAULT_SCHEME, "CPARTY")),
LocalDate.now(),
OffsetTime.now());
FraTrade tradeWrapper = new FraTrade(trade);
Result<MulticurveBundle> bundleResult = _discountingMulticurveCombinerFn.getMulticurveBundle(env, tradeWrapper);
if (bundleResult.isSuccess()) {
Set<String> curveNames = bundleResult.getValue().getCurveBuildingBlockBundle().getData().keySet();
Result<Map<String, CurveMatrixLabeller>> curveLabellers =
_curveLabellingFn.getCurveLabellers(curveNames);
if (curveLabellers.isSuccess()) {
FRACalculator calculator = new DiscountingFRACalculator(security,
bundleResult.getValue().getMulticurveProvider(),
_fraConverter,
env.getValuationTime(),
bundleResult.getValue().getCurveBuildingBlockBundle(),
curveLabellers.getValue());
return Result.success(calculator);
} else {
return Result.failure(curveLabellers);
}
} else {
return Result.failure(bundleResult);
}
}
@Override
public Result<FRACalculator> createCalculator(Environment env, ForwardRateAgreementSecurity security) {
Trade trade = new SimpleTrade(security,
BigDecimal.ONE,
new SimpleCounterparty(ExternalId.of(Counterparty.DEFAULT_SCHEME, "CPARTY")),
LocalDate.now(),
OffsetTime.now());
ForwardRateAgreementTrade tradeWrapper = new ForwardRateAgreementTrade(trade);
return createCalculator(env, tradeWrapper);
}
@Override
public Result<FRACalculator> createCalculator(Environment env, ForwardRateAgreementTrade trade) {
Result<MulticurveBundle> bundleResult = _discountingMulticurveCombinerFn.getMulticurveBundle(env, trade);
ForwardRateAgreementSecurity security = trade.getSecurity();
Result<HistoricalTimeSeriesBundle> fixings = _htsFn.getFixingsForSecurity(env, security);
if (Result.allSuccessful(bundleResult, fixings)) {
Set<String> curveNames = bundleResult.getValue().getCurveBuildingBlockBundle().getData().keySet();
Result<Map<String, CurveMatrixLabeller>> curveLabellers =
_curveLabellingFn.getCurveLabellers(curveNames);
if (curveLabellers.isSuccess()) {
FRACalculator calculator = new DiscountingFRACalculator(
security,
bundleResult.getValue().getMulticurveProvider(),
_fraConverter,
env.getValuationTime(),
_fixedIncomeConverterDataProvider,
fixings.getValue(),
bundleResult.getValue().getCurveBuildingBlockBundle(),
curveLabellers.getValue());
return Result.success(calculator);
} else {
return Result.failure(curveLabellers);
}
} else {
return Result.failure(bundleResult, fixings);
}
}
}