// collect the set of indices, validating they are IborIndex
private static ImmutableSet <IborIndex> buildIndices(RateComputation floatingRate)
{
ImmutableSet.Builder <Index> builder = ImmutableSet.builder();
floatingRate.collectIndices(builder);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
return(builder.build().Select(index => typeof(IborIndex).cast(index)).collect(toImmutableSet()));
}
private static ImmutableSet <string> getEntries(File jarFile, string rootPath)
{
ImmutableSet.Builder <string> builder = ImmutableSet.builder();
try
{
using (JarFile jar = new JarFile(jarFile))
{
IEnumerator <JarEntry> jarEntries = jar.entries();
while (jarEntries.MoveNext())
{
JarEntry entry = jarEntries.Current;
string entryName = entry.Name;
if (entryName.StartsWith(rootPath, StringComparison.Ordinal) && !entryName.Equals(rootPath))
{
string relativeEntryPath = entryName.Substring(rootPath.Length + 1);
if (relativeEntryPath.Trim().Length > 0)
{
builder.add(relativeEntryPath);
}
}
}
}
}
catch (Exception e)
{
throw new System.ArgumentException(Messages.format("Error scanning entries in JAR file: {}", jarFile), e);
}
return(builder.build());
}
/// <summary>
/// Returns the set of indices referred to by the cap/floor.
/// <para>
/// A cap/floor will typically refer to one index, such as 'GBP-LIBOR-3M'.
/// Calling this method will return the complete list of indices.
///
/// </para>
/// </summary>
/// <returns> the set of indices referred to by this cap/floor </returns>
public ImmutableSet <Index> allIndices()
{
ImmutableSet.Builder <Index> builder = ImmutableSet.builder();
builder.add(capFloorLeg.Calculation.Index);
if (payLeg != null)
{
payLeg.collectIndices(builder);
}
return(builder.build());
}
// collect the set of indices
private static ImmutableSet <Index> buildIndices(IList <ResolvedSwapLeg> legs)
{
// avoid streams as profiling showed a hotspot
ImmutableSet.Builder <Index> builder = ImmutableSet.builder();
foreach (ResolvedSwapLeg leg in legs)
{
leg.collectIndices(builder);
}
return(builder.build());
}
// collect the set of currencies
private static ImmutableSet <Currency> buildCurrencies(IList <ResolvedSwapLeg> legs)
{
// avoid streams as profiling showed a hotspot
ImmutableSet.Builder <Currency> builder = ImmutableSet.builder();
foreach (ResolvedSwapLeg leg in legs)
{
builder.add(leg.Currency);
}
return(builder.build());
}
// collect the set of indices
private static ImmutableSet <Index> buildIndices(ResolvedIborCapFloorLeg capFloorLeg, ResolvedSwapLeg payLeg)
{
ImmutableSet.Builder <Index> builder = ImmutableSet.builder();
builder.add(capFloorLeg.Index);
if (payLeg != null)
{
payLeg.collectIndices(builder);
}
return(builder.build());
}
// collect the set of currencies
private static ImmutableSet <Currency> buildCurrencies(ResolvedIborCapFloorLeg capFloorLeg, ResolvedSwapLeg payLeg)
{
ImmutableSet.Builder <Currency> builder = ImmutableSet.builder();
builder.add(capFloorLeg.Currency);
if (payLeg != null)
{
builder.add(payLeg.Currency);
}
return(builder.build());
}
/// <summary>
/// Creates a new function which invokes the delegate function, passes the result to the derived function
/// and returns the combined results.
/// </summary>
/// <param name="derivedFunction"> a function which calculates one measure using the measure values calculated by the other function </param>
/// <param name="delegate"> a function which calculates multiple measures </param>
internal DerivedCalculationFunctionWrapper(DerivedCalculationFunction <T, R> derivedFunction, CalculationFunction <T> @delegate)
{
this.derivedFunction = derivedFunction;
this.@delegate = @delegate;
ISet <Measure> delegateMeasures = @delegate.supportedMeasures();
//JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the java.util.Collection 'containsAll' method:
this.requiredMeasuresSupported = delegateMeasures.containsAll(derivedFunction.requiredMeasures());
this.supportedMeasures_Renamed = requiredMeasuresSupported ? ImmutableSet.builder <Measure>().addAll(delegateMeasures).add(derivedFunction.measure()).build() : delegateMeasures;
}
/// <summary>
/// Returns the set of rate indices referred to by the CMS.
/// <para>
/// The CMS leg will refer to one index, such as 'GBP-LIBOR-3M'.
/// The pay leg may refer to a different index.
/// The swap index will not be included.
///
/// </para>
/// </summary>
/// <returns> the set of indices referred to by this CMS </returns>
public ImmutableSet <Index> allRateIndices()
{
IborIndex cmsIndex = cmsLeg.UnderlyingIndex;
if (payLeg == null)
{
return(ImmutableSet.of(cmsIndex));
}
ImmutableSet.Builder <Index> builder = ImmutableSet.builder();
payLeg.collectIndices(builder);
builder.add(cmsIndex);
return(builder.build());
}
public ImmutableSet <Currency> allCurrencies()
{
if (payLeg == null)
{
return(ImmutableSet.of(cmsLeg.Currency));
}
else
{
ImmutableSet.Builder <Currency> builder = ImmutableSet.builder();
builder.add(cmsLeg.Currency);
builder.addAll(payLeg.allCurrencies());
return(builder.build());
}
}
public override ISet <string> tokens(Bean bean)
{
if (bean.propertyNames().size() == 1)
{
string singlePropertyName = Iterables.getOnlyElement(bean.propertyNames());
object propertyValue = bean.property(singlePropertyName).get();
ISet <string> valueTokens = ValuePathEvaluator.tokens(propertyValue);
return(ImmutableSet.builder <string>().add(singlePropertyName).addAll(valueTokens).build());
}
else
{
return(bean.propertyNames());
}
}
//-------------------------------------------------------------------------
public ResolvedSwap resolve(ReferenceData refData)
{
// avoid streams as profiling showed a hotspot
// most efficient to loop around legs once
ImmutableList.Builder <ResolvedSwapLeg> resolvedLegs = ImmutableList.builder();
ImmutableSet.Builder <Currency> currencies = ImmutableSet.builder();
ImmutableSet.Builder <Index> indices = ImmutableSet.builder();
foreach (SwapLeg leg in legs)
{
ResolvedSwapLeg resolvedLeg = leg.resolve(refData);
resolvedLegs.add(resolvedLeg);
currencies.add(resolvedLeg.Currency);
leg.collectIndices(indices);
}
return(new ResolvedSwap(resolvedLegs.build(), currencies.build(), indices.build()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Override @SuppressWarnings("unchecked") public <R> java.util.Set<com.opengamma.strata.data.MarketDataId<R>> findIds(com.opengamma.strata.data.MarketDataName<R> name)
public ISet <MarketDataId <R> > findIds <R>(MarketDataName <R> name)
{
ISet <MarketDataId <R> > ids = underlying.findIds(name);
if (id is NamedMarketDataId)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.NamedMarketDataId<?> named = (com.opengamma.strata.data.NamedMarketDataId<?>) id;
NamedMarketDataId <object> named = (NamedMarketDataId <object>)id;
if (named.MarketDataName.Equals(name))
{
return(ImmutableSet.builder <MarketDataId <R> >().addAll(ids).add((MarketDataId <R>)id).build());
}
}
return(ids);
}
//-------------------------------------------------------------------------
public virtual FunctionRequirements requirements(T target, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData)
{
// extract data from product
OvernightFuture product = target.Product;
QuoteId quoteId = QuoteId.of(target.Product.SecurityId.StandardId, FieldName.SETTLEMENT_PRICE);
OvernightIndex index = product.Index;
// use lookup to build requirements
RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup));
FunctionRequirements ratesReqs = ratesLookup.requirements(ImmutableSet.of(), ImmutableSet.of(index));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.google.common.collect.ImmutableSet<com.opengamma.strata.data.MarketDataId<?>> valueReqs = com.google.common.collect.ImmutableSet.builder<com.opengamma.strata.data.MarketDataId<?>>().add(quoteId).addAll(ratesReqs.getValueRequirements()).build();
ImmutableSet <MarketDataId <object> > valueReqs = ImmutableSet.builder <MarketDataId <object> >().add(quoteId).addAll(ratesReqs.ValueRequirements).build();
return(ratesReqs.toBuilder().valueRequirements(valueReqs).build());
}
//-------------------------------------------------------------------------
public virtual FunctionRequirements requirements(CmsTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData)
{
// extract data from product
Cms product = trade.Product;
ISet <Currency> currencies = product.allPaymentCurrencies();
IborIndex cmsIndex = trade.Product.CmsLeg.UnderlyingIndex;
ISet <Index> payIndices = trade.Product.allRateIndices();
ISet <Index> indices = ImmutableSet.builder <Index>().add(cmsIndex).addAll(payIndices).build();
// use lookup to build requirements
RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup));
FunctionRequirements ratesReqs = ratesLookup.requirements(currencies, indices);
SwaptionMarketDataLookup swaptionLookup = parameters.getParameter(typeof(SwaptionMarketDataLookup));
FunctionRequirements swaptionReqs = swaptionLookup.requirements(cmsIndex);
return(ratesReqs.combinedWith(swaptionReqs));
}
//-------------------------------------------------------------------------
/// <summary>
/// Merges multiple sets of requirements into a single set.
/// </summary>
/// <param name="requirements"> market data requirements </param>
/// <returns> a single set of requirements containing all the requirements from the input sets </returns>
public static MarketDataRequirements combine(IList <MarketDataRequirements> requirements)
{
ImmutableSet.Builder <ObservableId> observablesBuilder = ImmutableSet.builder();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.google.common.collect.ImmutableSet.Builder<com.opengamma.strata.data.MarketDataId<?>> nonObservablesBuilder = com.google.common.collect.ImmutableSet.builder();
ImmutableSet.Builder <MarketDataId <object> > nonObservablesBuilder = ImmutableSet.builder();
ImmutableSet.Builder <ObservableId> timeSeriesBuilder = ImmutableSet.builder();
ImmutableSet.Builder <Currency> outputCurrenciesBuilder = ImmutableSet.builder();
foreach (MarketDataRequirements req in requirements)
{
observablesBuilder.addAll(req.observables);
nonObservablesBuilder.addAll(req.nonObservables);
timeSeriesBuilder.addAll(req.timeSeries);
outputCurrenciesBuilder.addAll(req.outputCurrencies);
}
return(new MarketDataRequirements(observablesBuilder.build(), nonObservablesBuilder.build(), timeSeriesBuilder.build(), outputCurrenciesBuilder.build()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Override @SuppressWarnings("unchecked") public <T> java.util.Set<com.opengamma.strata.data.MarketDataId<T>> findIds(com.opengamma.strata.data.MarketDataName<T> name)
public ISet <MarketDataId <T> > findIds <T>(MarketDataName <T> name)
{
return(ImmutableSet.builder <MarketDataId <T> >().addAll(underlying1.findIds(name)).addAll(underlying2.findIds(name)).build());
}
//-------------------------------------------------------------------------
/// <summary>
/// Returns the set of indices referred to by the swap.
/// <para>
/// A swap will typically refer to at least one index, such as 'GBP-LIBOR-3M'.
/// Calling this method will return the complete list of indices, including
/// any associated with FX reset.
///
/// </para>
/// </summary>
/// <returns> the set of indices referred to by this swap </returns>
public ImmutableSet <Index> allIndices()
{
ImmutableSet.Builder <Index> builder = ImmutableSet.builder();
legs.ForEach(leg => leg.collectIndices(builder));
return(builder.build());
}
/// <summary>
/// Returns the set of currencies referred to by the swap.
/// <para>
/// This returns the complete set of currencies for the swap, not just the payment currencies.
///
/// </para>
/// </summary>
/// <returns> the set of currencies referred to by this swap </returns>
public ImmutableSet <Currency> allCurrencies()
{
ImmutableSet.Builder <Currency> builder = ImmutableSet.builder();
legs.ForEach(leg => leg.collectCurrencies(builder));
return(builder.build());
}
/// <summary>
/// Obtains a failure for multiple failure items.
/// </summary>
/// <param name="item"> the first failure item </param>
/// <param name="additionalItems"> additional failure items </param>
/// <returns> the failure </returns>
public static Failure of(FailureItem item, params FailureItem[] additionalItems)
{
return(of(ImmutableSet.builder <FailureItem>().add(item).add(additionalItems).build()));
}
/// <summary>
/// Returns a set containing any Ibor indices in the arguments.
/// </summary>
private static ISet <Index> indices(Index index, params Index[] otherIndices)
{
// The type parameter is needed for the benefit of the Eclipse compiler
return(ImmutableSet.builder <Index>().add(index).add(otherIndices).build());
}