// parses the public static final constants private static NamedLookup <R> parseConstants <R>(Type <R> enumType, Type constantsType) where R : Named { System.Reflection.FieldInfo[] fields = constantsType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); IDictionary <string, R> instances = new Dictionary <string, R>(); foreach (System.Reflection.FieldInfo field in fields) { if (Modifier.isPublic(field.Modifiers) && Modifier.isStatic(field.Modifiers) && Modifier.isFinal(field.Modifiers) && enumType.IsAssignableFrom(field.Type)) { if (Modifier.isPublic(constantsType.Modifiers) == false) { field.Accessible = true; } try { R instance = enumType.cast(field.get(null)); if (!instances.ContainsKey(instance.Name)) { instances.Add(instance.Name, instance); } if (!instances.ContainsKey(instance.Name.ToUpper(Locale.ENGLISH))) { instances.Add(instance.Name.ToUpper(Locale.ENGLISH), instance); } } catch (Exception ex) { throw new System.ArgumentException("Unable to query field: " + field, ex); } } } ImmutableMap <string, R> constants = ImmutableMap.copyOf(instances); return(new NamedLookupAnonymousInnerClass(constants)); }
/// <summary> /// Creates an instance. </summary> /// <param name="configs"> the value of the property, not null </param> /// <param name="defaultConfigs"> the value of the property, not null </param> internal MarketDataConfig(IDictionary <Type, SingleTypeMarketDataConfig> configs, IDictionary <Type, object> defaultConfigs) { JodaBeanUtils.notNull(configs, "configs"); JodaBeanUtils.notNull(defaultConfigs, "defaultConfigs"); this.configs = ImmutableMap.copyOf(configs); this.defaultConfigs = ImmutableMap.copyOf(defaultConfigs); }
// the input map is treated as being ordered //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ImmutableConstructor private CalculationParameters(java.util.Map<Class, CalculationParameter> parameters) private CalculationParameters(IDictionary <Type, CalculationParameter> parameters) { JodaBeanUtils.notNull(parameters, "parameters"); this.parameters = ImmutableMap.copyOf(parameters); // find parameters that are super-interfaces of the specified objects IDictionary <Type, Type> aliases = new Dictionary <Type, Type>(); foreach (Type type in parameters.Keys) { Type[] interfaces = type.GetInterfaces(); foreach (Type iface in interfaces) { if (iface != typeof(CalculationParameter) && iface.IsAssignableFrom(typeof(CalculationParameter)) && !parameters.ContainsKey(iface)) { // first registration wins with aliases Type aliasType = iface.asSubclass(typeof(CalculationParameter)); if (!aliases.ContainsKey(aliasType)) { aliases.Add(aliasType, type); } } } } this.aliases = ImmutableMap.copyOf(aliases); }
private CurveSensitivities(PortfolioItemInfo info, IDictionary <CurveSensitivitiesType, CurrencyParameterSensitivities> typedSensitivities) { JodaBeanUtils.notNull(info, "info"); JodaBeanUtils.notNull(typedSensitivities, "typedSensitivities"); this.info = info; this.typedSensitivities = ImmutableMap.copyOf(typedSensitivities); }
/// <summary> /// Creates an instance. </summary> /// <param name="currencies"> the value of the property, not null </param> /// <param name="rates"> the value of the property, not null </param> internal FxMatrix(IDictionary <Currency, int> currencies, DoubleMatrix rates) { JodaBeanUtils.notNull(currencies, "currencies"); JodaBeanUtils.notNull(rates, "rates"); this.currencies = ImmutableMap.copyOf(currencies); this.rates = rates; }
private SingleTypeMarketDataConfig(Type configType, IDictionary <string, object> configObjects) { JodaBeanUtils.notNull(configType, "configType"); JodaBeanUtils.notNull(configObjects, "configObjects"); this.configType = configType; this.configObjects = ImmutableMap.copyOf(configObjects); }
//------------------------------------------------------------------------- //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @VisibleForTesting static com.google.common.collect.ImmutableMap<String, HolidayCalendar> loadFromIni(String filename) internal static ImmutableMap <string, HolidayCalendar> loadFromIni(string filename) { IList <ResourceLocator> resources = ResourceConfig.orderedResources(filename); IDictionary <string, HolidayCalendar> map = new Dictionary <string, HolidayCalendar>(); foreach (ResourceLocator resource in resources) { try { IniFile ini = IniFile.of(resource.CharSource); foreach (string sectionName in ini.sections()) { PropertySet section = ini.section(sectionName); HolidayCalendar parsed = parseHolidayCalendar(sectionName, section); map[parsed.Name] = parsed; if (!map.ContainsKey(parsed.Name.ToUpper(Locale.ENGLISH))) { map.Add(parsed.Name.ToUpper(Locale.ENGLISH), parsed); } } } catch (Exception ex) { log.log(Level.SEVERE, "Error processing resource as Holiday Calendar INI file: " + resource, ex); return(ImmutableMap.of()); } } return(ImmutableMap.copyOf(map)); }
private JumpToDefault(Currency currency, IDictionary <StandardId, double> amounts) { JodaBeanUtils.notNull(currency, "currency"); JodaBeanUtils.notNull(amounts, "amounts"); this.currency = currency; this.amounts = ImmutableMap.copyOf(amounts); }
private static ImmutableMap <string, OvernightIndex> loadFromCsv() { IList <ResourceLocator> resources = ResourceConfig.orderedResources("OvernightIndexData.csv"); IDictionary <string, OvernightIndex> map = new Dictionary <string, OvernightIndex>(); foreach (ResourceLocator resource in resources) { try { CsvFile csv = CsvFile.of(resource.CharSource, true); foreach (CsvRow row in csv.rows()) { OvernightIndex parsed = parseOvernightIndex(row); map[parsed.Name] = parsed; if (!map.ContainsKey(parsed.Name.ToUpper(Locale.ENGLISH))) { map.Add(parsed.Name.ToUpper(Locale.ENGLISH), parsed); } } } catch (Exception ex) { log.log(Level.SEVERE, "Error processing resource as Overnight Index CSV file: " + resource, ex); return(ImmutableMap.of()); } } return(ImmutableMap.copyOf(map)); }
/// <summary> /// Creates an instance. </summary> /// <param name="shiftType"> the value of the property, not null </param> /// <param name="shifts"> the value of the property, not null </param> /// <param name="nodeIndices"> the value of the property, not null </param> internal PointShifts(ShiftType shiftType, DoubleMatrix shifts, IDictionary <object, int> nodeIndices) { JodaBeanUtils.notNull(shiftType, "shiftType"); JodaBeanUtils.notNull(shifts, "shifts"); JodaBeanUtils.notNull(nodeIndices, "nodeIndices"); this.shiftType = shiftType; this.shifts = shifts; this.nodeIndices = ImmutableMap.copyOf(nodeIndices); }
//------------------------------------------------------------------------- /// <summary> /// Creates an instance, based on the specified element. /// <para> /// The map of references is used to link one part of the XML to another. /// For example, if one part of the XML has {@code <foo id="fooId">}, the references /// map will contain an entry mapping "fooId" to the parsed element {@code <foo>}. /// /// </para> /// </summary> /// <param name="fpmlRootEl"> the source of the FpML XML document </param> /// <param name="references"> the map of id/href to referenced element </param> /// <param name="ourPartySelector"> the selector used to find "our" party within the set of parties in the FpML document </param> /// <param name="tradeInfoParser"> the trade info parser </param> /// <param name="refData"> the reference data to use </param> public FpmlDocument(XmlElement fpmlRootEl, IDictionary <string, XmlElement> references, FpmlPartySelector ourPartySelector, FpmlTradeInfoParserPlugin tradeInfoParser, ReferenceData refData) { this.fpmlRoot = fpmlRootEl; this.references = ImmutableMap.copyOf(references); this.parties = parseParties(fpmlRootEl); this.ourPartyHrefIds = findOurParty(ourPartySelector); this.tradeInfoParser = tradeInfoParser; this.refData = refData; }
private TradeCounterpartyCalculationParameter(Type queryType, IDictionary <StandardId, CalculationParameter> parameters, CalculationParameter defaultParameter) { JodaBeanUtils.notNull(queryType, "queryType"); JodaBeanUtils.notNull(parameters, "parameters"); JodaBeanUtils.notNull(defaultParameter, "defaultParameter"); this.queryType_Renamed = queryType; this.parameters = ImmutableMap.copyOf(parameters); this.defaultParameter = defaultParameter; }
private LegalEntityCurveGroup(CurveGroupName name, IDictionary <Pair <RepoGroup, Currency>, Curve> repoCurves, IDictionary <Pair <LegalEntityGroup, Currency>, Curve> issuerCurves) { JodaBeanUtils.notNull(name, "name"); JodaBeanUtils.notNull(repoCurves, "repoCurves"); JodaBeanUtils.notNull(issuerCurves, "issuerCurves"); this.name = name; this.repoCurves = ImmutableMap.copyOf(repoCurves); this.issuerCurves = ImmutableMap.copyOf(issuerCurves); }
// parse the config file FloatingRateName.ini internal static ImmutableMap <string, FloatingRateName> parseIndices(IniFile ini) { Dictionary <string, ImmutableFloatingRateName> map = new Dictionary <string, ImmutableFloatingRateName>(); parseSection(ini.section("ibor"), "-", FloatingRateType.IBOR, map); parseFixingDateOffset(ini.section("iborFixingDateOffset"), map); parseSection(ini.section("overnightCompounded"), "", FloatingRateType.OVERNIGHT_COMPOUNDED, map); parseSection(ini.section("overnightAveraged"), "", FloatingRateType.OVERNIGHT_AVERAGED, map); parseSection(ini.section("price"), "", FloatingRateType.PRICE, map); return(ImmutableMap.copyOf(map)); }
private DefaultCreditRatesMarketDataLookup(IDictionary <Pair <StandardId, Currency>, CurveId> creditCurveIds, IDictionary <Currency, CurveId> discountCurveIds, IDictionary <StandardId, CurveId> recoveryRateCurveIds, ObservableSource observableSource) { JodaBeanUtils.notNull(creditCurveIds, "creditCurveIds"); JodaBeanUtils.notNull(discountCurveIds, "discountCurveIds"); JodaBeanUtils.notNull(recoveryRateCurveIds, "recoveryRateCurveIds"); JodaBeanUtils.notNull(observableSource, "observableSource"); this.creditCurveIds = ImmutableMap.copyOf(creditCurveIds); this.discountCurveIds = ImmutableMap.copyOf(discountCurveIds); this.recoveryRateCurveIds = ImmutableMap.copyOf(recoveryRateCurveIds); this.observableSource = observableSource; }
//------------------------------------------------------------------------- //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ImmutableConstructor private FailureItem(FailureReason reason, String message, java.util.Map<String, String> attributes, String stackTrace, Class causeType) private FailureItem(FailureReason reason, string message, IDictionary <string, string> attributes, string stackTrace, Type causeType) { this.attributes = ImmutableMap.copyOf(attributes); JodaBeanUtils.notNull(reason, "reason"); JodaBeanUtils.notEmpty(message, "message"); JodaBeanUtils.notNull(stackTrace, "stackTrace"); this.reason = reason; this.message = message; this.stackTrace = INTERNER.intern(stackTrace); this.causeType = causeType; }
//------------------------------------------------------------------------- /// <summary> /// Build a new {@code FxMatrix} from the data in the builder. /// </summary> /// <returns> a new {@code FxMatrix} </returns> /// <exception cref="IllegalStateException"> if an attempt was made to add currencies /// which have no currency in common with other rates </exception> public virtual FxMatrix build() { if (disjointRates.Count > 0) { throw new System.InvalidOperationException("Received rates with no currencies in common with other: " + disjointRates); } // Trim array down to the correct size - we have to copy the array // anyway to ensure immutability, so we may as well remove any // unused rows return(new FxMatrix(ImmutableMap.copyOf(currencies), DoubleMatrix.ofUnsafe(copyArray(rates, currencies.size())))); }
/// <summary> /// Formats a templated message inserting named arguments. /// <para> /// A typical template would look like: /// <pre> /// Messages.formatWithAttributes("Foo={foo}, Bar={}", "abc", 123) /// </pre> /// This will return a <seealso cref="Pair"/> with a String and a Map. /// The String will be the formatted message: {@code "Foo=abc, Bar=123"}. /// The Map will look like: <code>{"foo": "123"}</code>. /// </para> /// <para> /// This method combines a template message with a list of specific arguments. /// It can be useful to delay string concatenation, which is sometimes a performance issue. /// The approach is similar to SLF4J MessageFormat, Guava Preconditions and String format(). /// </para> /// <para> /// The message template contains zero to many "{name}" placeholders. /// Each placeholder is replaced by the next available argument. /// If there are too few arguments, then the message will be left with placeholders. /// If there are too many arguments, then the excess arguments are appended to the message. /// No attempt is made to format the arguments. /// </para> /// <para> /// This method is null tolerant to ensure that use in exception construction will /// not throw another exception, which might hide the intended exception. /// /// </para> /// </summary> /// <param name="messageTemplate"> the message template with "{}" placeholders, null returns empty string </param> /// <param name="args"> the message arguments, null treated as empty array </param> /// <returns> the formatted message </returns> public static Pair <string, IDictionary <string, string> > formatWithAttributes(string messageTemplate, params object[] args) { if (string.ReferenceEquals(messageTemplate, null)) { return(formatWithAttributes("", args)); } if (args == null) { return(formatWithAttributes(messageTemplate)); } // do not use an ImmutableMap, as we avoid throwing exceptions in case of duplicate keys. IDictionary <string, string> attributes = new Dictionary <string, string>(); Matcher matcher = REGEX_PATTERN.matcher(messageTemplate); int argIndex = 0; StringBuilder outputMessageBuffer = new StringBuilder(); while (matcher.find()) { // if the number of placeholders is greater than the number of arguments, then not all placeholders are replaced. if (argIndex >= args.Length) { continue; } string attributeName = matcher.group(1); // extract the attribute name string replacement = args[argIndex].ToString().Replace("$", "\\$"); matcher.appendReplacement(outputMessageBuffer, replacement); if (attributeName.Length > 0) { attributes[attributeName] = replacement; } argIndex++; } matcher.appendTail(outputMessageBuffer); // append remaining args if (argIndex < args.Length) { outputMessageBuffer.Append(" - ["); for (int i = argIndex; i < args.Length; i++) { if (i > argIndex) { outputMessageBuffer.Append(", "); } outputMessageBuffer.Append(args[i]); } outputMessageBuffer.Append(']'); } return(Pair.of(outputMessageBuffer.ToString(), ImmutableMap.copyOf(attributes))); }
public override void reload(PrefabData data) { this.componentMap = ImmutableMap.copyOf(data.Components); this.persisted = data.Persisted; this.alwaysRelevant = data.AlwaysRelevant; this.parent = data.Parent; if (parent != null && parent is PojoPrefab) { ((PojoPrefab)parent).children.Add(this); } }
private ImmutableCreditRatesProvider(LocalDate valuationDate, IDictionary <Pair <StandardId, Currency>, LegalEntitySurvivalProbabilities> creditCurves, IDictionary <Currency, CreditDiscountFactors> discountCurves, IDictionary <StandardId, RecoveryRates> recoveryRateCurves) { JodaBeanUtils.notNull(valuationDate, "valuationDate"); JodaBeanUtils.notNull(creditCurves, "creditCurves"); JodaBeanUtils.notEmpty(discountCurves, "discountCurves"); JodaBeanUtils.notEmpty(recoveryRateCurves, "recoveryRateCurves"); this.valuationDate = valuationDate; this.creditCurves = ImmutableMap.copyOf(creditCurves); this.discountCurves = ImmutableMap.copyOf(discountCurves); this.recoveryRateCurves = ImmutableMap.copyOf(recoveryRateCurves); validate(); }
//------------------------------------------------------------------------- /// <summary> /// Obtains an instance from the specified parameters. /// <para> /// The map provides a lookup from the <seealso cref="CalculationTarget"/> implementation type /// to the appropriate parameter to use for that target. If a target is requested that /// is not in the map, the default parameter is used. /// /// </para> /// </summary> /// <param name="parameters"> the parameters, keyed by target type </param> /// <param name="defaultParameter"> the default parameter </param> /// <returns> the target aware parameter </returns> public static TradeCounterpartyCalculationParameter of(IDictionary <StandardId, CalculationParameter> parameters, CalculationParameter defaultParameter) { ArgChecker.notEmpty(parameters, "values"); ArgChecker.notNull(defaultParameter, "defaultParameter"); Type queryType = defaultParameter.queryType(); foreach (CalculationParameter value in parameters.Values) { if (value.queryType() != queryType) { throw new System.ArgumentException(Messages.format("Map contained a parameter '{}' that did not match the expected query type '{}'", value, queryType.GetType().Name)); } } return(new TradeCounterpartyCalculationParameter(queryType, ImmutableMap.copyOf(parameters), defaultParameter)); }
// build the search headers internal static ImmutableMap <string, int> buildSearchHeaders(ImmutableList <string> headers) { // need to allow duplicate headers and only store the first instance IDictionary <string, int> searchHeaders = new Dictionary <string, int>(); for (int i = 0; i < headers.size(); i++) { string searchHeader = headers.get(i).ToLower(Locale.ENGLISH); if (!searchHeaders.ContainsKey(searchHeader)) { searchHeaders.Add(searchHeader, i); } } return(ImmutableMap.copyOf(searchHeaders)); }
private ImmutableLegalEntityDiscountingProvider(LocalDate valuationDate, IDictionary <SecurityId, RepoGroup> repoCurveSecurityGroups, IDictionary <LegalEntityId, RepoGroup> repoCurveGroups, IDictionary <Pair <RepoGroup, Currency>, DiscountFactors> repoCurves, IDictionary <LegalEntityId, LegalEntityGroup> issuerCurveGroups, IDictionary <Pair <LegalEntityGroup, Currency>, DiscountFactors> issuerCurves) { JodaBeanUtils.notNull(valuationDate, "valuationDate"); JodaBeanUtils.notNull(repoCurveSecurityGroups, "repoCurveSecurityGroups"); JodaBeanUtils.notNull(repoCurveGroups, "repoCurveGroups"); JodaBeanUtils.notNull(repoCurves, "repoCurves"); JodaBeanUtils.notNull(issuerCurveGroups, "issuerCurveGroups"); JodaBeanUtils.notNull(issuerCurves, "issuerCurves"); this.valuationDate = valuationDate; this.repoCurveSecurityGroups = ImmutableMap.copyOf(repoCurveSecurityGroups); this.repoCurveGroups = ImmutableMap.copyOf(repoCurveGroups); this.repoCurves = ImmutableMap.copyOf(repoCurves); this.issuerCurveGroups = ImmutableMap.copyOf(issuerCurveGroups); this.issuerCurves = ImmutableMap.copyOf(issuerCurves); validate(); }
private DefaultLegalEntityDiscountingMarketDataLookup(IDictionary <SecurityId, RepoGroup> repoCurveSecurityGroups, IDictionary <LegalEntityId, RepoGroup> repoCurveGroups, IDictionary <Pair <RepoGroup, Currency>, CurveId> repoCurves, IDictionary <LegalEntityId, LegalEntityGroup> issuerCurveGroups, IDictionary <Pair <LegalEntityGroup, Currency>, CurveId> issuerCurves, ObservableSource observableSource) { JodaBeanUtils.notNull(repoCurveSecurityGroups, "repoCurveSecurityGroups"); JodaBeanUtils.notNull(repoCurveGroups, "repoCurveGroups"); JodaBeanUtils.notNull(repoCurves, "repoCurves"); JodaBeanUtils.notNull(issuerCurveGroups, "issuerCurveGroups"); JodaBeanUtils.notNull(issuerCurves, "issuerCurves"); JodaBeanUtils.notNull(observableSource, "observableSource"); this.repoCurveSecurityGroups = ImmutableMap.copyOf(repoCurveSecurityGroups); this.repoCurveGroups = ImmutableMap.copyOf(repoCurveGroups); this.repoCurves = ImmutableMap.copyOf(repoCurves); this.issuerCurveGroups = ImmutableMap.copyOf(issuerCurveGroups); this.issuerCurves = ImmutableMap.copyOf(issuerCurves); this.observableSource = observableSource; validate(); }
//------------------------------------------------------------------------- /// <summary> /// Returns the map of known instances by name. /// <para> /// This method returns all known instances. /// It is permitted for an enum provider implementation to return an empty map, /// thus the map may not be complete. /// The map may include instances keyed under an alternate name, such as names /// in upper case, however it will not include the base set of /// <seealso cref="#alternateNames() alternate names"/>. /// /// </para> /// </summary> /// <returns> the map of enum instance by name </returns> public ImmutableMap <string, T> lookupAll() { IDictionary <string, T> map = new Dictionary <string, T>(); foreach (NamedLookup <T> lookup in lookups) { IDictionary <string, T> lookupMap = lookup.lookupAll(); foreach (KeyValuePair <string, T> entry in lookupMap.SetOfKeyValuePairs()) { if (!map.ContainsKey(entry.Key)) { map.Add(entry.Key, entry.Value); } } } return(ImmutableMap.copyOf(map)); }
public virtual void test_bondDiscountingProvider() { LocalDate valDate = LocalDate.of(2015, 6, 30); Curve ccAUsd = ConstantNodalCurve.of(Curves.zeroRates(CC_A_USD.CurveName, ACT_365F), 0.5d, 1.5d); Curve ccBGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_B_GBP.CurveName, ACT_365F), 0.5d, 2d); Curve ccAGbp = ConstantNodalCurve.of(Curves.zeroRates(CC_A_GBP.CurveName, ACT_365F), 0.5d, 3d); Curve dcGbp = ConstantNodalCurve.of(Curves.zeroRates(DC_GBP.CurveName, ACT_365F), 0.5d, 0.1d); Curve dcUsd = ConstantNodalCurve.of(Curves.zeroRates(DC_USD.CurveName, ACT_365F), 0.5d, 0.05d); Curve rcA = ConstantCurve.of(Curves.recoveryRates(RC_A.CurveName, ACT_365F), 0.5d); Curve rcB = ConstantCurve.of(Curves.recoveryRates(RC_B.CurveName, ACT_365F), 0.4234d); IDictionary <CurveId, Curve> curveMap = new Dictionary <CurveId, Curve>(); curveMap[CC_A_USD] = ccAUsd; curveMap[CC_B_GBP] = ccBGbp; curveMap[CC_A_GBP] = ccAGbp; curveMap[DC_USD] = dcUsd; curveMap[DC_GBP] = dcGbp; curveMap[RC_A] = rcA; curveMap[RC_B] = rcB; MarketData md = ImmutableMarketData.of(valDate, ImmutableMap.copyOf(curveMap)); CreditRatesProvider provider = LOOKUP_WITH_SOURCE.creditRatesProvider(md); assertEquals(provider.ValuationDate, valDate); assertEquals(provider.findData(CC_A_USD.CurveName), ccAUsd); assertEquals(provider.findData(DC_USD.CurveName), dcUsd); assertEquals(provider.findData(RC_B.CurveName), rcB); assertEquals(provider.findData(CurveName.of("Rubbish")), null); // check credit curve LegalEntitySurvivalProbabilities cc = provider.survivalProbabilities(ISSUER_A, GBP); IsdaCreditDiscountFactors ccUnder = (IsdaCreditDiscountFactors)cc.SurvivalProbabilities; assertEquals(ccUnder.Curve.Name, ccAGbp.Name); assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_B, USD)); assertThrowsRuntime(() => provider.survivalProbabilities(ISSUER_C, USD)); // check discount curve IsdaCreditDiscountFactors dc = (IsdaCreditDiscountFactors)provider.discountFactors(USD); assertEquals(dc.Curve.Name, dcUsd.Name); assertThrowsRuntime(() => provider.discountFactors(EUR)); // check recovery rate curve ConstantRecoveryRates rc = (ConstantRecoveryRates)provider.recoveryRates(ISSUER_B); assertEquals(rc.RecoveryRate, rcB.getParameter(0)); assertThrowsRuntime(() => provider.recoveryRates(ISSUER_C)); }
// parses the alternate names private static ImmutableMap <string, string> parseAlternates(IniFile config) { if (!config.contains(ALTERNATES_SECTION)) { return(ImmutableMap.of()); } IDictionary <string, string> alternates = new Dictionary <string, string>(); foreach (KeyValuePair <string, string> entry in config.section(ALTERNATES_SECTION).asMap().entrySet()) { alternates[entry.Key] = entry.Value; if (!alternates.ContainsKey(entry.Key.ToUpper(Locale.ENGLISH))) { alternates.Add(entry.Key.ToUpper(Locale.ENGLISH), entry.Value); } } return(ImmutableMap.copyOf(alternates)); }
//------------------------------------------------------------------------ /// <summary> /// Creates an instance, specifying the headers and row. /// <para> /// See <seealso cref="CsvFile"/>. /// /// </para> /// </summary> /// <param name="headers"> the headers </param> /// <param name="fields"> the fields </param> private CsvRow(ImmutableList <string> headers, int lineNumber, ImmutableList <string> fields) { this.headers_Renamed = headers; // need to allow duplicate headers and only store the first instance IDictionary <string, int> searchHeaders = new Dictionary <string, int>(); for (int i = 0; i < headers.size(); i++) { string searchHeader = headers.get(i).ToLower(Locale.ENGLISH); if (!searchHeaders.ContainsKey(searchHeader)) { searchHeaders.Add(searchHeader, i); } } this.searchHeaders = ImmutableMap.copyOf(searchHeaders); this.lineNumber_Renamed = lineNumber; this.fields_Renamed = fields; }
/// <summary> /// Computes cash flow equivalent and sensitivity of fixed leg. /// <para> /// The return type is a map of {@code NotionalExchange} and {@code PointSensitivityBuilder}. /// /// </para> /// </summary> /// <param name="fixedLeg"> the fixed leg </param> /// <param name="ratesProvider"> the rates provider </param> /// <returns> the cash flow equivalent and sensitivity </returns> public static ImmutableMap <Payment, PointSensitivityBuilder> cashFlowEquivalentAndSensitivityFixedLeg(ResolvedSwapLeg fixedLeg, RatesProvider ratesProvider) { ArgChecker.isTrue(fixedLeg.Type.Equals(SwapLegType.FIXED), "Leg type should be FIXED"); ArgChecker.isTrue(fixedLeg.PaymentEvents.Empty, "PaymentEvent should be empty"); IDictionary <Payment, PointSensitivityBuilder> res = new Dictionary <Payment, PointSensitivityBuilder>(); foreach (SwapPaymentPeriod paymentPeriod in fixedLeg.PaymentPeriods) { ArgChecker.isTrue(paymentPeriod is RatePaymentPeriod, "rate payment should be RatePaymentPeriod"); RatePaymentPeriod ratePaymentPeriod = (RatePaymentPeriod)paymentPeriod; ArgChecker.isTrue(ratePaymentPeriod.AccrualPeriods.size() == 1, "rate payment should not be compounding"); RateAccrualPeriod rateAccrualPeriod = ratePaymentPeriod.AccrualPeriods.get(0); double factor = rateAccrualPeriod.YearFraction * ((FixedRateComputation)rateAccrualPeriod.RateComputation).Rate; CurrencyAmount notional = ratePaymentPeriod.NotionalAmount.multipliedBy(factor); LocalDate paymentDate = ratePaymentPeriod.PaymentDate; Payment pay = Payment.of(notional, paymentDate); res[pay] = PointSensitivityBuilder.none(); } return(ImmutableMap.copyOf(res)); }
/// <summary> /// Returns the map of known instances by normalized name. /// <para> /// This method returns all known instances, keyed by the normalized name. /// This is equivalent to the result of <seealso cref="#lookupAll()"/> adjusted such /// that each entry is keyed by the result of <seealso cref="Named#getName()"/>. /// /// </para> /// </summary> /// <returns> the map of enum instance by name </returns> public ImmutableMap <string, T> lookupAllNormalized() { // add values that are keyed under the normalized name // keep values keyed under a non-normalized name IDictionary <string, T> result = new Dictionary <string, T>(); IDictionary <string, T> others = new Dictionary <string, T>(); foreach (KeyValuePair <string, T> entry in lookupAll().entrySet()) { string normalizedName = entry.Value.Name; if (entry.Key.Equals(normalizedName)) { result[normalizedName] = entry.Value; } else { others[normalizedName] = entry.Value; } } // include any values that are only keyed under a non-normalized name others.Values.forEach(v => result.putIfAbsent(v.Name, v)); return(ImmutableMap.copyOf(result)); }