//-------------------------------------------------------------------------
// parses the file in grid format
private void parseGridFormat(CsvIterator csv, ListMultimap <string, CurveSensitivities> parsed, IList <FailureItem> failures)
{
// find the applicable reference columns
IDictionary <string, CurveName> references = new LinkedHashMap <string, CurveName>();
foreach (string header in csv.headers())
{
string headerLowerCase = header.ToLower(Locale.ENGLISH);
if (!REF_HEADERS.contains(headerLowerCase) && !resolver.isInfoColumn(headerLowerCase))
{
references[header] = CurveName.of(header);
}
}
// loop around all rows, peeking to match batches with the same identifier
// no exception catch at this level to avoid infinite loops
while (csv.hasNext())
{
CsvRow peekedRow = csv.peek();
PortfolioItemInfo info = parseInfo(peekedRow);
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
string id = info.Id.map(StandardId::toString).orElse("");
// process in batches, where the ID is the same
CurveSensitivitiesBuilder builder = CurveSensitivities.builder(info);
IList <CsvRow> batchRows = csv.nextBatch(r => matchId(r, id));
foreach (CsvRow batchRow in batchRows)
{
try
{
ParameterMetadata metadata = parseMetadata(batchRow, true);
CurveSensitivitiesType type = batchRow.findValue(TYPE_HEADER).map(str => CurveSensitivitiesType.of(str)).orElse(CurveSensitivitiesType.ZERO_RATE_DELTA);
foreach (KeyValuePair <string, CurveName> entry in references.SetOfKeyValuePairs())
{
CurveName reference = entry.Value;
CurveName resolvedCurveName = resolver.checkCurveName(reference);
string valueStr = batchRow.getField(entry.Key);
Currency currency = parseCurrency(batchRow, reference);
if (valueStr.Length > 0)
{
double value = LoaderUtils.parseDouble(valueStr);
builder.add(type, resolvedCurveName, currency, metadata, value);
}
}
}
catch (System.ArgumentException ex)
{
failures.Add(FailureItem.of(PARSING, "CSV file could not be parsed at line {}: {}", batchRow.lineNumber(), ex.Message));
}
}
CurveSensitivities sens = builder.build();
if (!sens.TypedSensitivities.Empty)
{
parsed.put(sens.Id.map(object.toString).orElse(""), sens);
}
}
}
//-------------------------------------------------------------------------
// parses the file in standard format
private void parseStandardFormat(CsvIterator csv, ListMultimap <string, CurveSensitivities> parsed, IList <FailureItem> failures)
{
// loop around all rows, peeking to match batches with the same identifier
// no exception catch at this level to avoid infinite loops
while (csv.hasNext())
{
CsvRow peekedRow = csv.peek();
PortfolioItemInfo info = parseInfo(peekedRow);
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
string id = info.Id.map(StandardId::toString).orElse("");
// process in batches, where the ID is the same
CurveSensitivitiesBuilder builder = CurveSensitivities.builder(info);
IList <CsvRow> batchRows = csv.nextBatch(r => matchId(r, id));
foreach (CsvRow batchRow in batchRows)
{
try
{
CurveName reference = CurveName.of(batchRow.getValue(REFERENCE_HEADER));
CurveName resolvedCurveName = resolver.checkCurveName(reference);
CurveSensitivitiesType type = CurveSensitivitiesType.of(batchRow.getValue(TYPE_HEADER));
ParameterMetadata metadata = parseMetadata(batchRow, false);
Currency currency = parseCurrency(batchRow, reference);
string valueStr = batchRow.getField(VALUE_HEADER);
if (valueStr.Length > 0)
{
double value = LoaderUtils.parseDouble(valueStr);
builder.add(type, resolvedCurveName, currency, metadata, value);
}
}
catch (System.ArgumentException ex)
{
failures.Add(FailureItem.of(PARSING, "CSV file could not be parsed at line {}: {}", batchRow.lineNumber(), ex.Message));
}
}
CurveSensitivities sens = builder.build();
if (!sens.TypedSensitivities.Empty)
{
parsed.put(sens.Id.map(object.toString).orElse(""), sens);
}
}
}
// 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));
}