public override EvaluationResult evaluate(Security security, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
MetaBean metaBean = MetaBean.of(security.GetType());
// security
Optional <string> securityPropertyName = metaBean.metaPropertyMap().Keys.Where(p => p.equalsIgnoreCase(firstToken)).First();
if (securityPropertyName.Present)
{
object propertyValue = metaBean.metaProperty(securityPropertyName.get()).get((Bean)security);
return(propertyValue != null?EvaluationResult.success(propertyValue, remainingTokens) : EvaluationResult.failure("Property '{}' not set", firstToken));
}
// security info
Optional <string> securityInfoPropertyName = security.Info.propertyNames().Where(p => p.equalsIgnoreCase(firstToken)).First();
if (securityInfoPropertyName.Present)
{
object propertyValue = security.Info.property(securityInfoPropertyName.get()).get();
return(propertyValue != null?EvaluationResult.success(propertyValue, remainingTokens) : EvaluationResult.failure("Property '{}' not set", firstToken));
}
// security price info
Optional <string> securityPriceInfoPropertyName = security.Info.PriceInfo.propertyNames().Where(p => p.equalsIgnoreCase(firstToken)).First();
if (securityPriceInfoPropertyName.Present)
{
object propertyValue = security.Info.PriceInfo.property(securityPriceInfoPropertyName.get()).get();
return(propertyValue != null?EvaluationResult.success(propertyValue, remainingTokens) : EvaluationResult.failure("Property '{}' not set", firstToken));
}
// not found
return(invalidTokenFailure(security, firstToken));
}
public override EvaluationResult evaluate <T1>(IEnumerable <T1> iterable, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
string token = firstToken.ToLower(Locale.ENGLISH);
int? index = Ints.tryParse(token);
if (index != null)
{
try
{
return(EvaluationResult.success(Iterables.get(iterable, index), remainingTokens));
}
catch (System.IndexOutOfRangeException)
{
return(invalidTokenFailure(iterable, token));
}
}
ISet <string> tokens = this.tokens(iterable);
foreach (object item in iterable)
{
if (!fieldValues(item).Contains(token))
{
continue;
}
if (!tokens.Contains(token))
{
return(ambiguousTokenFailure(iterable, token));
}
return(EvaluationResult.success(item, remainingTokens));
}
return(invalidTokenFailure(iterable, token));
}
public override EvaluationResult evaluate(ResultsRow resultsRow, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
ValueRootType rootType = ValueRootType.parseToken(firstToken);
switch (rootType.innerEnumValue)
{
case com.opengamma.strata.report.framework.expression.ValueRootType.InnerEnum.MEASURES:
return(evaluateMeasures(resultsRow, functions, remainingTokens));
case com.opengamma.strata.report.framework.expression.ValueRootType.InnerEnum.PRODUCT:
return(EvaluationResult.of(resultsRow.Product, remainingTokens));
case com.opengamma.strata.report.framework.expression.ValueRootType.InnerEnum.SECURITY:
return(EvaluationResult.of(resultsRow.Security, remainingTokens));
case com.opengamma.strata.report.framework.expression.ValueRootType.InnerEnum.TRADE:
return(EvaluationResult.of(resultsRow.Trade, remainingTokens));
case com.opengamma.strata.report.framework.expression.ValueRootType.InnerEnum.POSITION:
return(EvaluationResult.of(resultsRow.Position, remainingTokens));
case com.opengamma.strata.report.framework.expression.ValueRootType.InnerEnum.TARGET:
return(EvaluationResult.success(resultsRow.Target, remainingTokens));
default:
throw new System.ArgumentException("Unknown root token '" + rootType.token() + "'");
}
}
public override EvaluationResult evaluate(Trade trade, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
MetaBean metaBean = MetaBean.of(trade.GetType());
// trade
Optional <string> tradePropertyName = metaBean.metaPropertyMap().Keys.Where(p => p.equalsIgnoreCase(firstToken)).First();
if (tradePropertyName.Present)
{
object propertyValue = metaBean.metaProperty(tradePropertyName.get()).get((Bean)trade);
if (propertyValue == null)
{
return(EvaluationResult.failure("Property '{}' not set", firstToken));
}
return(EvaluationResult.success(propertyValue, remainingTokens));
}
// trade info
Optional <string> tradeInfoPropertyName = trade.Info.propertyNames().Where(p => p.equalsIgnoreCase(firstToken)).First();
if (tradeInfoPropertyName.Present)
{
object propertyValue = trade.Info.property(tradeInfoPropertyName.get()).get();
if (propertyValue == null)
{
return(EvaluationResult.failure("Property '{}' not set", firstToken));
}
return(EvaluationResult.success(propertyValue, remainingTokens));
}
return(invalidTokenFailure(trade, firstToken));
}
public override EvaluationResult evaluate(Position position, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
MetaBean metaBean = MetaBean.of(position.GetType());
// position
Optional <string> positionPropertyName = metaBean.metaPropertyMap().Keys.Where(p => p.equalsIgnoreCase(firstToken)).First();
if (positionPropertyName.Present)
{
object propertyValue = metaBean.metaProperty(positionPropertyName.get()).get((Bean)position);
return(propertyValue != null?EvaluationResult.success(propertyValue, remainingTokens) : EvaluationResult.failure("Property '{}' not set", firstToken));
}
// position info
Optional <string> positionInfoPropertyName = position.Info.propertyNames().Where(p => p.equalsIgnoreCase(firstToken)).First();
if (positionInfoPropertyName.Present)
{
object propertyValue = position.Info.property(positionInfoPropertyName.get()).get();
return(propertyValue != null?EvaluationResult.success(propertyValue, remainingTokens) : EvaluationResult.failure("Property '{}' not set", firstToken));
}
// not found
return(invalidTokenFailure(position, firstToken));
}
public override EvaluationResult evaluate(CurrencyParameterSensitivity sensitivity, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
if (firstToken.Equals(sensitivity.Currency.Code, StringComparison.OrdinalIgnoreCase) || firstToken.Equals(sensitivity.MarketDataName.Name, StringComparison.OrdinalIgnoreCase))
{
return(EvaluationResult.success(sensitivity, remainingTokens));
}
else
{
return(invalidTokenFailure(sensitivity, firstToken));
}
}
public override EvaluationResult evaluate(CurrencyAmount amount, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
if (firstToken.Equals(CURRENCY_FIELD, StringComparison.OrdinalIgnoreCase))
{
return(EvaluationResult.success(amount.Currency, remainingTokens));
}
if (firstToken.Equals(AMOUNT_FIELD, StringComparison.OrdinalIgnoreCase))
{
// Can be rendered directly - retains the currency for formatting purposes
return(EvaluationResult.success(amount, remainingTokens));
}
return(invalidTokenFailure(amount, firstToken));
}
public override EvaluationResult evaluate(CurrencyParameterSensitivities sensitivities, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <CurrencyParameterSensitivity> matchingSensitivities = sensitivities.Sensitivities.Where(sensitivity => matchesToken(sensitivity, firstToken)).collect(toImmutableList());
switch (matchingSensitivities.Count)
{
case 0:
return(invalidTokenFailure(sensitivities, firstToken));
case 1:
return(EvaluationResult.success(matchingSensitivities[0], remainingTokens));
default:
return(EvaluationResult.success(CurrencyParameterSensitivities.of(matchingSensitivities), remainingTokens));
}
}
public override EvaluationResult evaluate(Bean bean, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
Optional <string> propertyName = bean.propertyNames().Where(p => p.equalsIgnoreCase(firstToken)).First();
if (propertyName.Present)
{
object propertyValue = bean.property(propertyName.get()).get();
return(propertyValue != null?EvaluationResult.success(propertyValue, remainingTokens) : EvaluationResult.failure("No value available for property '{}'", firstToken));
}
// The bean has a single property which doesn't match the token.
// Return the property value without consuming any tokens.
// This allows skipping over properties when the bean only has a single property.
if (bean.propertyNames().size() == 1)
{
string singlePropertyName = Iterables.getOnlyElement(bean.propertyNames());
object propertyValue = bean.property(singlePropertyName).get();
IList <string> tokens = ImmutableList.builder <string>().add(firstToken).addAll(remainingTokens).build();
return(propertyValue != null?EvaluationResult.success(propertyValue, tokens) : EvaluationResult.failure("No value available for property '{}'", firstToken));
}
return(invalidTokenFailure(bean, firstToken));
}
public override EvaluationResult evaluate <T1>(IDictionary <T1> map, CalculationFunctions functions, string firstToken, IList <string> remainingTokens)
{
return(MapStream.of(map).filterKeys(key => firstToken.Equals(key.ToString(), StringComparison.OrdinalIgnoreCase)).findFirst().map(e => EvaluationResult.success(e.Value, remainingTokens)).orElse(invalidTokenFailure(map, firstToken)));
}