public void test_parse_grid_full()
{
CharSource source = ResourceLocator.ofClasspath("com/opengamma/strata/loader/csv/sensitivity-grid-full.csv").CharSource;
assertEquals(LOADER_CCP.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER_CCP.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 0, test.Failures.ToString());
IList <CurveSensitivities> list0 = test.Value.get("SCHEME~TR1");
assertEquals(list0.Count, 1);
CurveSensitivities csens0 = list0[0];
assertEquals(csens0.Id, StandardId.of("SCHEME", "TR1"));
assertEquals(csens0.Info.getAttribute(CCP_ATTR), "LCH");
assertEquals(csens0.TypedSensitivities.size(), 2);
assertSens(csens0, ZERO_RATE_DELTA, "GBCURVE", GBP, "1M, 3M, 6M", 1, 2, 3);
assertSens(csens0, ZERO_RATE_GAMMA, "GBCURVE", GBP, "1M, 3M, 6M", 4, 5, 6);
IList <CurveSensitivities> list1 = test.Value.get("OG-Sensitivity~TR2");
assertEquals(list1.Count, 1);
CurveSensitivities csens1 = list1[0];
assertEquals(csens1.Id, StandardId.of("OG-Sensitivity", "TR2"));
assertEquals(csens1.Info.getAttribute(CCP_ATTR), "CME");
assertEquals(csens1.TypedSensitivities.size(), 1);
assertSens(csens1, ZERO_RATE_DELTA, "GBCURVE", GBP, "1M, 3M, 6M", 7, 8, 9);
}
//-------------------------------------------------------------------------
public virtual void test_parse_future()
{
EtdContractSpecId specId = EtdContractSpecId.of("OG-ETD", "F-ECAG-FGBL");
EtdContractSpec contract = EtdContractSpec.builder().id(specId).type(EtdType.FUTURE).exchangeId(ExchangeIds.ECAG).contractCode(FGBL).description("Dummy").priceInfo(SecurityPriceInfo.of(Currency.GBP, 100)).build();
ReferenceData refData = ImmutableReferenceData.of(specId, contract);
PositionCsvLoader test = PositionCsvLoader.of(refData);
ValueWithFailures <IList <EtdFuturePosition> > trades = test.parse(ImmutableList.of(FILE.CharSource), typeof(EtdFuturePosition));
IList <EtdFuturePosition> filtered = trades.Value;
assertEquals(filtered.Count, 4);
EtdFuturePosition expected1 = EtdFuturePosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123421")).build()).security(EtdFutureSecurity.of(contract, YearMonth.of(2017, 6), EtdVariant.ofMonthly())).longQuantity(15d).shortQuantity(2d).build();
assertBeanEquals(expected1, filtered[0]);
EtdFuturePosition expected2 = EtdFuturePosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123422")).build()).security(EtdFutureSecurity.of(contract, YearMonth.of(2017, 6), EtdVariant.ofFlexFuture(13, EtdSettlementType.CASH))).longQuantity(0d).shortQuantity(13d).build();
assertBeanEquals(expected2, filtered[1]);
EtdFuturePosition expected3 = EtdFuturePosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123423")).build()).security(EtdFutureSecurity.of(contract, YearMonth.of(2017, 6), EtdVariant.ofWeekly(2))).longQuantity(0d).shortQuantity(20d).build();
assertBeanEquals(expected3, filtered[2]);
EtdFuturePosition expected4 = EtdFuturePosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123424")).build()).security(EtdFutureSecurity.of(contract, YearMonth.of(2017, 6), EtdVariant.ofDaily(3))).longQuantity(30d).shortQuantity(0d).build();
assertBeanEquals(expected4, filtered[3]);
}
//-------------------------------------------------------------------------
public void test_parse_list()
{
CharSource source = ResourceLocator.ofClasspath("com/opengamma/strata/loader/csv/sensitivity-list.csv").CharSource;
assertEquals(LOADER.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 0, test.Failures.ToString());
assertEquals(test.Value.size(), 1);
IList <CurveSensitivities> list = test.Value.get("");
assertEquals(list.Count, 1);
CurveSensitivities csens0 = list[0];
assertEquals(csens0.TypedSensitivities.size(), 3);
string tenors = "1D, 1W, 2W, 1M, 3M, 6M, 12M, 2Y, 5Y, 10Y";
assertSens(csens0, ZERO_RATE_DELTA, "GBP", GBP, tenors, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
assertSens(csens0, ZERO_RATE_DELTA, "GBP-LIBOR", GBP, tenors, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
assertSens(csens0, ZERO_RATE_GAMMA, "GBP", GBP, tenors, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1);
assertSens(csens0, ZERO_RATE_GAMMA, "GBP-LIBOR", GBP, tenors, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1);
assertSens(csens0, OTHER, "GBP", GBP, tenors, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0);
assertSens(csens0, OTHER, "GBP-LIBOR", GBP, tenors, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0);
}
public void test_write_standard_roundTrip()
{
CharSource source = ResourceLocator.ofClasspath("com/opengamma/strata/loader/csv/sensitivity-standard.csv").CharSource;
ValueWithFailures <ListMultimap <string, CurveSensitivities> > parsed1 = LOADER.parse(ImmutableList.of(source));
assertEquals(parsed1.Failures.size(), 0, parsed1.Failures.ToString());
assertEquals(parsed1.Value.size(), 1);
IList <CurveSensitivities> csensList1 = parsed1.Value.get("");
assertEquals(csensList1.Count, 1);
CurveSensitivities csens1 = csensList1[0];
StringBuilder buf = new StringBuilder();
WRITER.write(csens1, buf);
string content = buf.ToString();
ValueWithFailures <ListMultimap <string, CurveSensitivities> > parsed2 = LOADER.parse(ImmutableList.of(CharSource.wrap(content)));
assertEquals(parsed2.Failures.size(), 0, parsed2.Failures.ToString());
assertEquals(parsed2.Value.size(), 1);
IList <CurveSensitivities> csensList2 = parsed2.Value.get("");
assertEquals(csensList2.Count, 1);
CurveSensitivities csens2 = csensList2[0];
assertEquals(csens2, csens1);
}
public void test_parse_list_badDayMonthTenor()
{
CharSource source = CharSource.wrap("Reference,Sensitivity Tenor,Zero Rate Delta\n" + "GBP-LIBOR,P2M1D,1.0");
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
assertEquals(test.Failures.get(0).Reason, FailureReason.PARSING);
assertEquals(test.Failures.get(0).Message, "CSV file could not be parsed at line 2: Invalid tenor, cannot mix years/months and days: 2M1D");
}
public void test_parse_list_ioException()
{
CharSource source = new CharSourceAnonymousInnerClass(this);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
assertEquals(test.Failures.get(0).Reason, FailureReason.PARSING);
assertEquals(test.Failures.get(0).Message.StartsWith("CSV file could not be parsed: "), true);
assertEquals(test.Failures.get(0).Message.contains("Oops"), true);
}
public void test_parse_list_unableToGetCurrency()
{
CharSource source = CharSource.wrap("Reference,Sensitivity Tenor,Zero Rate Delta\n" + "X,1D,1.0");
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
FailureItem failure0 = test.Failures.get(0);
assertEquals(failure0.Reason, FailureReason.PARSING);
assertEquals(failure0.Message, "CSV file could not be parsed at line 2: Unable to parse currency from reference, " + "consider adding a 'Currency' column");
}
public virtual void test_load_invalidNoType()
{
PositionCsvLoader test = PositionCsvLoader.standard();
ValueWithFailures <IList <Position> > trades = test.parse(ImmutableList.of(CharSource.wrap("Id")));
assertEquals(trades.Failures.size(), 1);
FailureItem failure = trades.Failures.get(0);
assertEquals(failure.Reason, FailureReason.PARSING);
assertEquals(failure.Message.Contains("CSV file does not contain 'Strata Position Type' header"), true);
}
public virtual void test_load_invalidUnknownType()
{
PositionCsvLoader test = PositionCsvLoader.standard();
ValueWithFailures <IList <Position> > trades = test.parse(ImmutableList.of(CharSource.wrap("Strata Position Type\nFoo")));
assertEquals(trades.Failures.size(), 1);
FailureItem failure = trades.Failures.get(0);
assertEquals(failure.Reason, FailureReason.PARSING);
assertEquals(failure.Message, "CSV file position type 'Foo' is not known at line 2");
}
//-------------------------------------------------------------------------
/// <summary>
/// Parses one or more CSV format position files, returning sensitivities.
/// <para>
/// The standard way to write sensitivities files is for each file to contain one sensitivity instance.
/// The file format can handle multiple instances per file, where each instance has a separate identifier.
/// Most files will not have the identifier columns, thus the identifier will be the empty string.
/// </para>
/// <para>
/// The returned multimap is keyed by identifier. The value will contain one entry for each instance.
/// If desired, the results can be reduced using <seealso cref="CurveSensitivities#mergedWith(CurveSensitivities)"/>
/// to merge those with the same identifier.
/// </para>
/// <para>
/// CSV files sometimes contain a Unicode Byte Order Mark.
/// Callers are responsible for handling this, such as by using <seealso cref="UnicodeBom"/>.
///
/// </para>
/// </summary>
/// <param name="charSources"> the CSV character sources </param>
/// <returns> the loaded sensitivities, parsing errors are captured in the result </returns>
public ValueWithFailures <ListMultimap <string, CurveSensitivities> > parse(ICollection <CharSource> charSources)
{
ListMultimap <string, CurveSensitivities> parsed = ArrayListMultimap.create();
IList <FailureItem> failures = new List <FailureItem>();
foreach (CharSource charSource in charSources)
{
parse(charSource, parsed, failures);
}
return(ValueWithFailures.of(ImmutableListMultimap.copyOf(parsed), failures));
}
public virtual void test_load_genericSecurity()
{
PositionCsvLoader test = PositionCsvLoader.standard();
ValueWithFailures <IList <Position> > trades = test.load(FILE);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <GenericSecurityPosition> filtered = trades.Value.Where(typeof(GenericSecurityPosition).isInstance).Select(typeof(GenericSecurityPosition).cast).collect(toImmutableList());
assertEquals(filtered.Count, 1);
assertBeanEquals(SECURITY3FULL, filtered[0]);
}
//-------------------------------------------------------------------------
public void test_parse_list_allRowsBadNoEmptySensitvityCreated()
{
CharSource source = CharSource.wrap("Reference,Sensitivity Tenor,ZeroRateDelta\n" + "GBP,XX,1\n");
assertEquals(LOADER_DATE.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER_DATE.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
assertEquals(test.Value.size(), 0);
FailureItem failure0 = test.Failures.get(0);
assertEquals(failure0.Reason, FailureReason.PARSING);
assertEquals(failure0.Message, "CSV file could not be parsed at line 2: Invalid tenor 'XX', must be expressed as nD, nW, nM or nY");
}
public void test_parse_grid_badTenorWithValidDateColumn()
{
CharSource source = CharSource.wrap("Sensitivity Type,Sensitivity Tenor,Sensitivity Date,GBP\n" + "ZeroRateGamma,XXX,2018-06-30,1\n");
assertEquals(LOADER.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
assertEquals(test.Value.size(), 0);
FailureItem failure0 = test.Failures.get(0);
assertEquals(failure0.Reason, FailureReason.PARSING);
assertEquals(failure0.Message, "CSV file could not be parsed at line 2: Invalid tenor 'XXX', must be expressed as nD, nW, nM or nY");
}
public void test_parse_grid_dateButTenorRequired()
{
CharSource source = CharSource.wrap("Sensitivity Type,Sensitivity Tenor,Sensitivity Date,GBP\n" + "ZeroRateGamma,,2018-06-30,1\n");
assertEquals(LOADER.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
assertEquals(test.Value.size(), 0);
FailureItem failure0 = test.Failures.get(0);
assertEquals(failure0.Reason, FailureReason.PARSING);
assertEquals(failure0.Message, "CSV file could not be parsed at line 2: Missing value for 'Sensitivity Tenor' column");
}
public virtual void test_load_invalidNoQuantity()
{
EtdContractSpecId specId = EtdContractSpecId.of("OG-ETD", "F-ECAG-FGBL");
EtdContractSpec contract = EtdContractSpec.builder().id(specId).type(EtdType.FUTURE).exchangeId(ExchangeIds.ECAG).contractCode(FGBL).description("Dummy").priceInfo(SecurityPriceInfo.of(Currency.GBP, 100)).build();
ReferenceData refData = ImmutableReferenceData.of(specId, contract);
PositionCsvLoader test = PositionCsvLoader.of(refData);
ValueWithFailures <IList <Position> > trades = test.parse(ImmutableList.of(CharSource.wrap("Strata Position Type,Exchange,Contract Code,Expiry\nFUT,ECAG,FGBL,2017-06")));
assertEquals(trades.Failures.size(), 1);
FailureItem failure = trades.Failures.get(0);
assertEquals(failure.Reason, FailureReason.PARSING);
assertEquals(failure.Message, "CSV file position could not be parsed at line 2: " + "Security must contain a quantity column, either 'Quantity' or 'Long Quantity' and 'Short Quantity'");
}
public void test_parse_grid_missingColumns()
{
CharSource source = CharSource.wrap("GBP\n" + "1");
assertEquals(LOADER.isKnownFormat(source), false);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
assertEquals(test.Value.size(), 0);
FailureItem failure0 = test.Failures.get(0);
assertEquals(failure0.Reason, FailureReason.PARSING);
assertEquals(failure0.Message, "CSV file could not be parsed as sensitivities, invalid format");
}
public void test_parse_standard_dateInTenorColumn()
{
CharSource source = CharSource.wrap("Reference,Sensitivity Type,Sensitivity Tenor,Value\n" + "GBP,ZeroRateGamma,2018-06-30,1\n");
assertEquals(LOADER_DATE.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER_DATE.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
assertEquals(test.Value.size(), 0);
FailureItem failure0 = test.Failures.get(0);
assertEquals(failure0.Reason, FailureReason.PARSING);
assertEquals(failure0.Message, "CSV file could not be parsed at line 2: Invalid tenor '2018-06-30', must be expressed as nD, nW, nM or nY");
}
public void test_parse_grid_neitherTenorNorDate()
{
CharSource source = CharSource.wrap("Sensitivity Type,Sensitivity Tenor,Sensitivity Date,GBP\n" + "ZeroRateGamma,,,1\n");
assertEquals(LOADER_DATE.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER_DATE.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 1);
assertEquals(test.Value.size(), 0);
FailureItem failure0 = test.Failures.get(0);
assertEquals(failure0.Reason, FailureReason.PARSING);
assertEquals(failure0.Message, "CSV file could not be parsed at line 2: Unable to parse tenor or date, " + "check 'Sensitivity Tenor' and 'Sensitivity Date' columns");
}
public void test_parse_list_duplicateTenor()
{
CharSource source = CharSource.wrap("Reference,Sensitivity Tenor,Zero Rate Delta\n" + "GBP,P1D,1\n" + "GBP,P1M,2\n" + "GBP,P1M,3\n");
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 0, test.Failures.ToString());
assertEquals(test.Value.size(), 1);
IList <CurveSensitivities> list = test.Value.get("");
assertEquals(list.Count, 1);
CurveSensitivities csens0 = list[0];
assertEquals(csens0.TypedSensitivities.size(), 1);
assertSens(csens0, ZERO_RATE_DELTA, "GBP", GBP, "1D, 1M", 1, 5);
}
/// <summary>
/// Parses one or more CSV format trade files with a quiet type filter.
/// <para>
/// A type is specified to filter the trades.
/// Trades that do not match the type are silently dropped.
/// </para>
/// <para>
/// CSV files sometimes contain a Unicode Byte Order Mark.
/// Callers are responsible for handling this, such as by using <seealso cref="UnicodeBom"/>.
///
/// </para>
/// </summary>
/// @param <T> the trade type </param>
/// <param name="charSources"> the CSV character sources </param>
/// <param name="tradeType"> the trade type to return </param>
/// <returns> the loaded trades, all errors are captured in the result </returns>
public ValueWithFailures <IList <T> > parse <T>(ICollection <CharSource> charSources, Type <T> tradeType) where T : com.opengamma.strata.product.Trade
{
try
{
ValueWithFailures <IList <T> > result = ValueWithFailures.of(ImmutableList.of());
foreach (CharSource charSource in charSources)
{
ValueWithFailures <IList <T> > singleResult = parseFile(charSource, tradeType);
result = result.combinedWith(singleResult, Guavate.concatToList);
}
return(result);
}
catch (Exception ex)
{
return(ValueWithFailures.of(ImmutableList.of(), FailureItem.of(FailureReason.ERROR, ex)));
}
}
public void test_parse_grid_duplicateTenor()
{
CharSource source = CharSource.wrap("Sensitivity Type,Sensitivity Tenor,GBP\n" + "ZeroRateGamma,P6M,1\n" + "ZeroRateGamma,12M,2\n" + "ZeroRateGamma,12M,3\n");
assertEquals(LOADER_DATE.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER_DATE.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 0, test.Failures.ToString());
assertEquals(test.Value.size(), 1);
IList <CurveSensitivities> list = test.Value.get("");
assertEquals(list.Count, 1);
CurveSensitivities csens0 = list[0];
assertEquals(csens0.TypedSensitivities.size(), 1);
assertSens(csens0, ZERO_RATE_GAMMA, "GBP", GBP, "6M, 1Y", 1, 5); // 12M -> 1Y
}
// loads a single CSV file, filtering by trade type
private ValueWithFailures <IList <T> > parseFile <T>(CharSource charSource, Type <T> tradeType) where T : com.opengamma.strata.product.Trade
{
try
{
using (CsvIterator csv = CsvIterator.of(charSource, true))
{
if (!csv.headers().contains(TYPE_FIELD))
{
return(ValueWithFailures.of(ImmutableList.of(), FailureItem.of(FailureReason.PARSING, "CSV file does not contain '{header}' header: {}", TYPE_FIELD, charSource)));
}
return(parseFile(csv, tradeType));
}
}
catch (Exception ex)
{
return(ValueWithFailures.of(ImmutableList.of(), FailureItem.of(FailureReason.PARSING, ex, "CSV file could not be parsed: {exceptionMessage}: {}", ex.Message, charSource)));
}
}
/// <summary>
/// Parses one or more CSV format trade files with an error-creating type filter.
/// <para>
/// A list of types is specified to filter the trades.
/// Trades that do not match the type will be included in the failure list.
/// </para>
/// <para>
/// CSV files sometimes contain a Unicode Byte Order Mark.
/// Callers are responsible for handling this, such as by using <seealso cref="UnicodeBom"/>.
///
/// </para>
/// </summary>
/// <param name="charSources"> the CSV character sources </param>
/// <param name="tradeTypes"> the trade types to return </param>
/// <returns> the loaded trades, all errors are captured in the result </returns>
public ValueWithFailures <IList <Trade> > parse(ICollection <CharSource> charSources, IList <Type> tradeTypes)
{
ValueWithFailures <IList <Trade> > parsed = parse(charSources, typeof(Trade));
IList <Trade> valid = new List <Trade>();
IList <FailureItem> failures = new List <FailureItem>(parsed.Failures);
foreach (Trade trade in parsed.Value)
{
if (tradeTypes.Contains(trade.GetType()))
{
valid.Add(trade);
}
else
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
failures.Add(FailureItem.of(FailureReason.PARSING, "Trade type not allowed {tradeType}, only these types are supported: {}", trade.GetType().FullName, tradeTypes.Select(t => t.SimpleName).collect(joining(", "))));
}
}
return(ValueWithFailures.of(valid, failures));
}
//-------------------------------------------------------------------------
public virtual void test_parseLightweight()
{
PositionCsvLoader test = PositionCsvLoader.standard();
ValueWithFailures <IList <SecurityPosition> > trades = test.parseLightweight(ImmutableList.of(FILE.CharSource));
IList <SecurityPosition> filtered = trades.Value;
assertEquals(filtered.Count, 10);
assertBeanEquals(SECURITY1, filtered[0]);
assertBeanEquals(SECURITY2, filtered[1]);
assertBeanEquals(SECURITY3, filtered[2]);
SecurityPosition expected3 = SecurityPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123421")).build()).securityId(EtdIdUtils.futureId(ExchangeIds.ECAG, FGBL, YearMonth.of(2017, 6), EtdVariant.ofMonthly())).longQuantity(15d).shortQuantity(2d).build();
assertBeanEquals(expected3, filtered[3]);
SecurityPosition expected4 = SecurityPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123422")).build()).securityId(EtdIdUtils.futureId(ExchangeIds.ECAG, FGBL, YearMonth.of(2017, 6), EtdVariant.ofFlexFuture(13, EtdSettlementType.CASH))).longQuantity(0d).shortQuantity(13d).build();
assertBeanEquals(expected4, filtered[4]);
SecurityPosition expected5 = SecurityPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123423")).build()).securityId(EtdIdUtils.futureId(ExchangeIds.ECAG, FGBL, YearMonth.of(2017, 6), EtdVariant.ofWeekly(2))).longQuantity(0d).shortQuantity(20d).build();
assertBeanEquals(expected5, filtered[5]);
SecurityPosition expected6 = SecurityPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123424")).build()).securityId(EtdIdUtils.futureId(ExchangeIds.ECAG, FGBL, YearMonth.of(2017, 6), EtdVariant.ofDaily(3))).longQuantity(30d).shortQuantity(0d).build();
assertBeanEquals(expected6, filtered[6]);
SecurityPosition expected7 = SecurityPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123431")).build()).securityId(EtdIdUtils.optionId(ExchangeIds.ECAG, OGBL, YearMonth.of(2017, 6), EtdVariant.ofMonthly(), 0, PutCall.PUT, 3d, YearMonth.of(2017, 9))).longQuantity(15d).shortQuantity(2d).build();
assertBeanEquals(expected7, filtered[7]);
SecurityPosition expected8 = SecurityPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123432")).build()).securityId(EtdIdUtils.optionId(ExchangeIds.ECAG, OGBL, YearMonth.of(2017, 6), EtdVariant.ofFlexOption(13, EtdSettlementType.CASH, EtdOptionType.AMERICAN), 0, PutCall.CALL, 4d)).longQuantity(0d).shortQuantity(13d).build();
assertBeanEquals(expected8, filtered[8]);
SecurityPosition expected9 = SecurityPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123433")).build()).securityId(EtdIdUtils.optionId(ExchangeIds.ECAG, OGBL, YearMonth.of(2017, 6), EtdVariant.ofWeekly(2), 0, PutCall.PUT, 5.1d)).longQuantity(0d).shortQuantity(20d).build();
assertBeanEquals(expected9, filtered[9]);
}
//-------------------------------------------------------------------------
public void test_parse_multipleSources()
{
CharSource source1 = CharSource.wrap("Reference,Sensitivity Tenor,Zero Rate Delta\n" + "GBP-LIBOR,P1M,1.1\n" + "GBP-LIBOR,P2M,1.2\n");
CharSource source2 = CharSource.wrap("Reference,Sensitivity Tenor,Zero Rate Delta\n" + "GBP-LIBOR,P3M,1.3\n" + "GBP-LIBOR,P6M,1.4\n");
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER.parse(ImmutableList.of(source1, source2));
assertEquals(test.Failures.size(), 0, test.Failures.ToString());
assertEquals(test.Value.Keys.Count, 1);
IList <CurveSensitivities> list = test.Value.get("");
assertEquals(list.Count, 2);
CurveSensitivities csens0 = list[0];
assertEquals(csens0.TypedSensitivities.size(), 1);
assertSens(csens0, ZERO_RATE_DELTA, "GBP-LIBOR", GBP, "1M, 2M", 1.1, 1.2);
CurveSensitivities csens1 = list[1];
assertEquals(csens1.TypedSensitivities.size(), 1);
assertSens(csens1, ZERO_RATE_DELTA, "GBP-LIBOR", GBP, "3M, 6M", 1.3, 1.4);
}
//-------------------------------------------------------------------------
public virtual void test_parse_option()
{
EtdContractSpecId specId = EtdContractSpecId.of("OG-ETD", "O-ECAG-OGBL");
EtdContractSpec contract = EtdContractSpec.builder().id(specId).type(EtdType.OPTION).exchangeId(ExchangeIds.ECAG).contractCode(OGBL).description("Dummy").priceInfo(SecurityPriceInfo.of(Currency.GBP, 100)).build();
ReferenceData refData = ImmutableReferenceData.of(specId, contract);
PositionCsvLoader test = PositionCsvLoader.of(refData);
ValueWithFailures <IList <EtdOptionPosition> > trades = test.parse(ImmutableList.of(FILE.CharSource), typeof(EtdOptionPosition));
IList <EtdOptionPosition> filtered = trades.Value;
assertEquals(filtered.Count, 3);
EtdOptionPosition expected1 = EtdOptionPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123431")).build()).security(EtdOptionSecurity.of(contract, YearMonth.of(2017, 6), EtdVariant.ofMonthly(), 0, PutCall.PUT, 3d, YearMonth.of(2017, 9))).longQuantity(15d).shortQuantity(2d).build();
assertBeanEquals(expected1, filtered[0]);
EtdOptionPosition expected2 = EtdOptionPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123432")).build()).security(EtdOptionSecurity.of(contract, YearMonth.of(2017, 6), EtdVariant.ofFlexOption(13, EtdSettlementType.CASH, EtdOptionType.AMERICAN), 0, PutCall.CALL, 4d)).longQuantity(0d).shortQuantity(13d).build();
assertBeanEquals(expected2, filtered[1]);
EtdOptionPosition expected3 = EtdOptionPosition.builder().info(PositionInfo.builder().id(StandardId.of("OG", "123433")).build()).security(EtdOptionSecurity.of(contract, YearMonth.of(2017, 6), EtdVariant.ofWeekly(2), 0, PutCall.PUT, 5.1d)).longQuantity(0d).shortQuantity(20d).build();
assertBeanEquals(expected3, filtered[2]);
}
public void test_parse_grid_dateInTenorColumn()
{
CharSource source = CharSource.wrap("Sensitivity Type,Sensitivity Tenor,GBP\n" + "ZeroRateGamma,2018-06-30,1\n");
assertEquals(LOADER_DATE.isKnownFormat(source), true);
ValueWithFailures <ListMultimap <string, CurveSensitivities> > test = LOADER_DATE.parse(ImmutableList.of(source));
assertEquals(test.Failures.size(), 0, test.Failures.ToString());
assertEquals(test.Value.size(), 1);
IList <CurveSensitivities> list = test.Value.get("");
assertEquals(list.Count, 1);
CurveSensitivities csens0 = list[0];
assertEquals(csens0.TypedSensitivities.size(), 1);
CurrencyParameterSensitivities cpss = csens0.getTypedSensitivity(ZERO_RATE_GAMMA);
assertEquals(cpss.Sensitivities.size(), 1);
CurrencyParameterSensitivity cps = cpss.Sensitivities.get(0);
assertEquals(cps.ParameterMetadata.size(), 1);
assertEquals(cps.ParameterMetadata.get(0), LabelDateParameterMetadata.of(date(2018, 6, 30), "2018-06-30"));
}
// loads a single CSV file
private ValueWithFailures <IList <T> > parseFile <T>(CsvIterator csv, Type <T> tradeType) where T : com.opengamma.strata.product.Trade
{
IList <T> trades = new List <T>();
IList <FailureItem> failures = new List <FailureItem>();
while (csv.hasNext())
{
CsvRow row = csv.next();
try
{
string typeRaw = row.getField(TYPE_FIELD);
TradeInfo info = parseTradeInfo(row);
switch (typeRaw.ToUpper(Locale.ENGLISH))
{
case "FRA":
if (tradeType == typeof(FraTrade) || tradeType == typeof(Trade))
{
trades.Add(tradeType.cast(FraTradeCsvLoader.parse(row, info, resolver)));
}
break;
case "SECURITY":
if (tradeType == typeof(SecurityTrade) || tradeType == typeof(GenericSecurityTrade) || tradeType == typeof(ResolvableSecurityTrade) || tradeType == typeof(Trade))
{
SecurityQuantityTrade parsed = SecurityCsvLoader.parseTrade(row, info, resolver);
if (tradeType.IsInstanceOfType(parsed))
{
trades.Add(tradeType.cast(parsed));
}
}
break;
case "SWAP":
if (tradeType == typeof(SwapTrade) || tradeType == typeof(Trade))
{
IList <CsvRow> variableRows = new List <CsvRow>();
while (csv.hasNext() && csv.peek().getField(TYPE_FIELD).ToUpper(Locale.ENGLISH).Equals("VARIABLE"))
{
variableRows.Add(csv.next());
}
trades.Add(tradeType.cast(SwapTradeCsvLoader.parse(row, variableRows, info, resolver)));
}
break;
case "TERMDEPOSIT":
case "TERM DEPOSIT":
if (tradeType == typeof(TermDepositTrade) || tradeType == typeof(Trade))
{
trades.Add(tradeType.cast(TermDepositTradeCsvLoader.parse(row, info, resolver)));
}
break;
case "VARIABLE":
failures.Add(FailureItem.of(FailureReason.PARSING, "CSV file contained a 'Variable' type at line {lineNumber} that was not preceeded by a 'Swap'", row.lineNumber()));
break;
case "FX":
case "FXSINGLE":
case "FX SINGLE":
if (tradeType == typeof(FxSingleTrade) || tradeType == typeof(FxTrade) || tradeType == typeof(Trade))
{
trades.Add(tradeType.cast(FxSingleTradeCsvLoader.parse(row, info, resolver)));
}
break;
case "FXSWAP":
case "FX SWAP":
if (tradeType == typeof(FxSwapTrade) || tradeType == typeof(FxTrade) || tradeType == typeof(Trade))
{
trades.Add(tradeType.cast(FxSwapTradeCsvLoader.parse(row, info, resolver)));
}
break;
default:
failures.Add(FailureItem.of(FailureReason.PARSING, "CSV file trade type '{tradeType}' is not known at line {lineNumber}", typeRaw, row.lineNumber()));
break;
}
}
catch (Exception ex)
{
failures.Add(FailureItem.of(FailureReason.PARSING, ex, "CSV file trade could not be parsed at line {lineNumber}: {exceptionMessage}", row.lineNumber(), ex.Message));
}
}
return(ValueWithFailures.of(trades, failures));
}
// loads a single CSV file
private ValueWithFailures <IList <T> > parseFile <T>(CsvIterator csv, Type <T> posType) where T : com.opengamma.strata.product.Position
{
IList <T> positions = new List <T>();
IList <FailureItem> failures = new List <FailureItem>();
int line = 2;
foreach (CsvRow row in (IEnumerable <CsvRow>)() => csv)
{
try
{
PositionInfo info = parsePositionInfo(row);
Optional <string> typeRawOpt = row.findValue(TYPE_FIELD);
if (typeRawOpt.Present)
{
// type specified
string type = typeRawOpt.get().ToUpper(Locale.ENGLISH);
switch (type.ToUpper(Locale.ENGLISH))
{
case "SEC":
case "SECURITY":
if (posType == typeof(SecurityPosition) || posType == typeof(ResolvableSecurityPosition))
{
positions.Add(posType.cast(SecurityCsvLoader.parseSecurityPosition(row, info, resolver)));
}
else if (posType == typeof(GenericSecurityPosition) || posType == typeof(Position))
{
Position parsed = SecurityCsvLoader.parseNonEtdPosition(row, info, resolver);
if (posType.IsInstanceOfType(parsed))
{
positions.Add(posType.cast(parsed));
}
}
break;
case "FUT":
case "FUTURE":
if (posType == typeof(EtdPosition) || posType == typeof(EtdFuturePosition) || posType == typeof(ResolvableSecurityPosition) || posType == typeof(Position))
{
positions.Add(posType.cast((Position)resolver.parseEtdFuturePosition(row, info)));
}
else if (posType == typeof(SecurityPosition))
{
positions.Add(posType.cast(resolver.parseEtdFutureSecurityPosition(row, info)));
}
break;
case "OPT":
case "OPTION":
if (posType == typeof(EtdPosition) || posType == typeof(EtdOptionPosition) || posType == typeof(ResolvableSecurityPosition) || posType == typeof(Position))
{
positions.Add(posType.cast(resolver.parseEtdOptionPosition(row, info)));
}
else if (posType == typeof(SecurityPosition))
{
positions.Add(posType.cast(resolver.parseEtdOptionSecurityPosition(row, info)));
}
break;
default:
failures.Add(FailureItem.of(FailureReason.PARSING, "CSV file position type '{positionType}' is not known at line {lineNumber}", typeRawOpt.get(), line));
break;
}
}
else
{
// infer type
if (posType == typeof(SecurityPosition))
{
positions.Add(posType.cast(SecurityCsvLoader.parsePositionLightweight(row, info, resolver)));
}
else
{
Position position = SecurityCsvLoader.parsePosition(row, info, resolver);
if (posType.IsInstanceOfType(position))
{
positions.Add(posType.cast(position));
}
}
}
}
catch (Exception ex)
{
failures.Add(FailureItem.of(FailureReason.PARSING, ex, "CSV file position could not be parsed at line {lineNumber}: {exceptionMessage}", line, ex.Message));
}
line++;
}
return(ValueWithFailures.of(positions, failures));
}
