/** * Finds an instance by name. * <p> * This finds the instance matching the specified name. * Instances may have alternate names (aliases), thus the returned instance * may have a name other than that requested. * * @param name the enum name to return * @return the named enum */ public Optional<T> find(String name) { for (ExtendedEnum<? extends T> child : children) { @SuppressWarnings("unchecked") Optional<T> found = (Optional<T>) child.find(name); if (found.isPresent()) { return found; } } return Optional.empty(); }
private static IborFixingDepositConvention createByName(String name) { return IborIndex.extendedEnum().find(name) .map(index -> ImmutableIborFixingDepositConvention.of(index)) .orElse(null); }
private static FraConvention createByName(String name) { return IborIndex.extendedEnum().find(name) .map(index -> ImmutableFraConvention.of(index)) .orElse(null); }
/** * Looks up an instance by name leniently. * <p> * This finds the instance matching the specified name using a lenient lookup strategy. * An extended enum may include additional configuration defining how lenient search occurs. * * @param name the enum name to return * @return the named enum * @throws IllegalArgumentException if the name is not found */ public Optional<T> findLenient(String name) { Optional<T> alreadyValid = find(name); if (alreadyValid.isPresent()) { return alreadyValid; } String current = name.toUpperCase(Locale.ENGLISH); for (Pair<Pattern, String> pair : lenientRegex) { Matcher matcher = pair.getFirst().matcher(current); if (matcher.matches()) { current = matcher.replaceFirst(pair.getSecond()); } } return find(current); }
/** * Obtains an instance from the specified unique name. * * @param uniqueName the unique name * @return the convention * @throws IllegalArgumentException if the name is not known */ @FromString public static SingleCurrencySwapConvention of(String uniqueName) { ArgChecker.notNull(uniqueName, "uniqueName"); return Guavate.firstNonEmpty( () -> FixedIborSwapConvention.extendedEnum().find(uniqueName), () -> IborIborSwapConvention.extendedEnum().find(uniqueName), () -> FixedOvernightSwapConvention.extendedEnum().find(uniqueName), () -> OvernightIborSwapConvention.extendedEnum().find(uniqueName), () -> FixedInflationSwapConvention.extendedEnum().find(uniqueName), () -> ThreeLegBasisSwapConvention.extendedEnum().find(uniqueName)) .orElseThrow(() -> new IllegalArgumentException("SingleCurrencySwapConvention not found: " + uniqueName)); }
private static boolean knownReference(String refStr) { try { Optional<IborIndex> ibor = IborIndex.extendedEnum().find(refStr); if (ibor.isPresent()) { return true; } else { Optional<FloatingRateName> frName = FloatingRateName.extendedEnum().find(refStr); if (frName.isPresent()) { return true; } else if (refStr.length() == 3) { Currency.of(refStr); // this may throw an exception validating the string return true; } else { return false; } } } catch (RuntimeException ex) { return false; } }
/** * Tries to parse a string, with extended handling of indices. * <p> * This tries a number of ways to parse the input: * <ul> * <li>{@link FloatingRateName#of(String)} * <li>{@link IborIndex#of(String)} * <li>{@link OvernightIndex#of(String)} * <li>{@link PriceIndex#of(String)} * </ul> * Note that if an {@link IborIndex} is parsed, the tenor will be lost. * * @param str the string to parse * @return the floating rate, empty if not found */ public static Optional<FloatingRateName> tryParse(String str) { Optional<FloatingRateName> frnOpt = FloatingRateName.extendedEnum().find(str); if (frnOpt.isPresent()) { return frnOpt; } return FloatingRateIndex.tryParse(str).map(FloatingRateIndex::getFloatingRateName); }
Optional<IborIndex> iborOpt = IborIndex.extendedEnum().find(indexStr); if (iborOpt.isPresent()) { return (Optional) iborOpt; Optional<OvernightIndex> overnightOpt = OvernightIndex.extendedEnum().find(indexStr); if (overnightOpt.isPresent()) { return (Optional) overnightOpt; Optional<PriceIndex> priceOpt = PriceIndex.extendedEnum().find(indexStr); if (priceOpt.isPresent()) { return (Optional) priceOpt; Optional<FloatingRateName> frnOpt = FloatingRateName.extendedEnum().find(indexStr); if (frnOpt.isPresent()) { return frnOpt
private static Currency parseCurrency(CsvRow row, CurveName reference) { Optional<String> currencyStr = row.findValue(CURRENCY_HEADER); if (currencyStr.isPresent()) { return LoaderUtils.parseCurrency(currencyStr.get()); } String referenceStr = reference.getName().toUpperCase(Locale.ENGLISH); try { Optional<IborIndex> ibor = IborIndex.extendedEnum().find(referenceStr); if (ibor.isPresent()) { return ibor.get().getCurrency(); } else { Optional<FloatingRateName> frName = FloatingRateName.extendedEnum().find(referenceStr); if (frName.isPresent()) { return frName.get().getCurrency(); } else if (referenceStr.length() == 3) { return Currency.of(referenceStr); } else if (referenceStr.length() > 3 && referenceStr.charAt(3) == '-' || referenceStr.charAt(3) == '_') { return LoaderUtils.parseCurrency(referenceStr.substring(0, 3)); } else { // drop out to exception } } } catch (RuntimeException ex) { // drop out to exception } throw new IllegalArgumentException("Unable to parse currency from reference, consider adding a 'Currency' column"); }
private static RateCalculation parseRateCalculation( CsvRow row, String leg, FloatingRateIndex index, DayCount defaultFixedLegDayCount, BusinessDayAdjustment bda, Currency currency) { if (index instanceof IborIndex) { return parseIborRateCalculation(row, leg, (IborIndex) index, bda, currency); } else if (index instanceof OvernightIndex) { Optional<FloatingRateName> frnOpt = FloatingRateName.extendedEnum().find(getValue(row, leg, INDEX_FIELD)); if (frnOpt.isPresent()) { FloatingRateName frn = frnOpt.get(); if (frn.getType() == FloatingRateType.OVERNIGHT_AVERAGED) { return parseOvernightRateCalculation(row, leg, (OvernightIndex) index, OvernightAccrualMethod.AVERAGED); } } return parseOvernightRateCalculation(row, leg, (OvernightIndex) index, OvernightAccrualMethod.COMPOUNDED); } else if (index instanceof PriceIndex) { return parseInflationRateCalculation(row, leg, (PriceIndex) index, currency); } else { return parseFixedRateCalculation(row, leg, currency, defaultFixedLegDayCount); } }
assertEquals(test.alternateNames(), ImmutableMap.of("Alternate", "Standard", "ALTERNATE", "Standard")); assertEquals(test.getType(), SampleNamed.class); assertEquals(test.find("Standard"), Optional.of(SampleNameds.STANDARD)); assertEquals(test.find("STANDARD"), Optional.of(SampleNameds.STANDARD)); assertEquals(test.find("Rubbish"), Optional.empty()); assertEquals(test.lookup("Standard"), SampleNameds.STANDARD); assertEquals(test.lookup("Alternate"), SampleNameds.STANDARD);
PeriodAdditionConvention.extendedEnum().find(row.getField(TENOR_CONVENTION_FIELD)) .orElse(PeriodAdditionConventions.NONE); BusinessDayConvention tenorBusinessConvention = BusinessDayConvention.extendedEnum().find(row.getField(TENOR_CONVENTION_FIELD)) .orElse(isEndOfMonth(periodAdditionConvention) ? MODIFIED_FOLLOWING : FOLLOWING); BusinessDayAdjustment adj = BusinessDayAdjustment.of(tenorBusinessConvention, effectiveCal);