Set the providers to be considered. If not set explicitly the <i>default</i> ISO currencies as
returned by {@link java.util.Currency} is used.

@param rateTypes the rate types to use, not null.
@return the query for chaining.
338460
public ConversionQueryBuilder setRateTypes(RateType... rateTypes) {
        return set(ConversionQuery.KEY_RATE_TYPES, new HashSet<>(Arrays.asList(rateTypes)));
    }
1241548
public void setAdjustmentTypes(java.util.Collection<AdjustmentType> adjustmentTypes) {
        if (adjustmentTypes == null) {
            this.adjustmentTypes = null;
            return;
        }

        this.adjustmentTypes = new com.amazonaws.internal.SdkInternalList<AdjustmentType>(adjustmentTypes);
    }
93527
public ExchangeRateBuilder setRateChain(ExchangeRate... exchangeRates) {
        this.rateChain.clear();
        if (exchangeRates!=null) {
            this.rateChain.addAll(Arrays.asList(exchangeRates.clone()));
        }
        return this;
    }
49205
public static ProviderContextBuilder of(String provider, Collection<RateType> rateTypes) {
        return new ProviderContextBuilder(provider, rateTypes);
    }
1174760
public ExchangeRateBuilder setRateChain(List<ExchangeRate> exchangeRates) {
        this.rateChain.clear();
        if (Objects.nonNull(exchangeRates)) {
            this.rateChain.addAll(exchangeRates);
        }
        return this;
    }
922231
public static Collection<String> getFormatProviderNames() {
        Collection<String> providers = Optional.ofNullable(getMonetaryFormatsSpi()).orElseThrow(
                () -> new MonetaryException(
                        "No MonetaryFormatsSingletonSpi loaded, query functionality is not available."))
                .getProviderNames();
        if (Objects.isNull(providers)) {
            Logger.getLogger(MonetaryFormats.class.getName()).warning(
                    "No supported rate/conversion providers returned by SPI: " +
                            getMonetaryFormatsSpi().getClass().getName());
            return Collections.emptySet();
        }
        return providers;
    }
726615
@SuppressWarnings("unchecked")
	public <T> Converter<T> getDefaultConverter(Type type) {
		return (null == defaultConverterMap) ? null : (Converter<T>) defaultConverterMap.get(type);
	}
637879
private void addCurrencyInfo(TypeSpec.Builder type, NumberData data) {
    addCurrencyInfoMethod(type, "getCurrencySymbol", data.currencySymbols);
    addCurrencyInfoMethod(type, "getNarrowCurrencySymbol", data.narrowCurrencySymbols);
    addCurrencyInfoMethod(type, "getCurrencyDisplayName", data.currencyDisplayName);

    MethodSpec.Builder method = MethodSpec.methodBuilder("getCurrencyPluralName")
        .addModifiers(PROTECTED)
        .addParameter(Types.CLDR_CURRENCY_ENUM, "code")
        .addParameter(PluralCategory.class, "category")
        .returns(String.class);

    method.beginControlFlow("switch (code)");
    for (Map.Entry<String, Map<String, String>> currencyMap : data.currencyDisplayNames.entrySet()) {
      String code = currencyMap.getKey();
      Map<String, String> mapping = currencyMap.getValue();
      if (mapping.isEmpty()) {
        continue;
      }
      
      method.beginControlFlow("case $L:", code);
      method.beginControlFlow("switch (category)");
      for (Map.Entry<String, String> entry : mapping.entrySet()) {
        String[] parts = entry.getKey().split("-");
        PluralCategory category = PluralCategory.fromString(parts[2]);
        if (category == PluralCategory.OTHER) {
          method.addStatement("case $L:\ndefault: return $S", category, entry.getValue());
        } else {
          method.addStatement("case $L: return $S", category, entry.getValue());
        }
      }
      method.endControlFlow();
      method.endControlFlow();
    }
    
    method.addStatement("default: return $S", "");
    method.endControlFlow();
    
    type.addMethod(method.build());
    
    method = MethodSpec.methodBuilder("getCurrencyDigits")
        .addModifiers(PUBLIC)
        .addParameter(Types.CLDR_CURRENCY_ENUM, "code")
        .returns(int.class);
    method.addStatement("return _CurrencyUtil.getCurrencyDigits(code)");
    type.addMethod(method.build());
  }
1140601
public void setTypeaheadValues(java.lang.Object _typeaheadValues) {
		getStateHelper().put(PropertyKeys.typeaheadValues, _typeaheadValues);
	}
14855
public void setPlatformTypes(java.util.Collection<String> platformTypes) {
        if (platformTypes == null) {
            this.platformTypes = null;
            return;
        }

        this.platformTypes = new com.amazonaws.internal.SdkInternalList<String>(platformTypes);
    }
1156821
private void setupTypes() {
    if (!cache2kConfigurationWasProvided) {
      cache2kConfiguration.setKeyType(config.getKeyType());
      cache2kConfiguration.setValueType(config.getValueType());
    } else {
      if (cache2kConfiguration.getKeyType() == null) {
        cache2kConfiguration.setKeyType(config.getKeyType());
      }
      if (cache2kConfiguration.getValueType() == null) {
        cache2kConfiguration.setValueType(config.getValueType());
      }
    }
    keyType = cache2kConfiguration.getKeyType();
    valueType = cache2kConfiguration.getValueType();
    if (!config.getKeyType().equals(Object.class) && !config.getKeyType().equals(keyType.getType())) {
      throw new IllegalArgumentException("Key type mismatch between JCache and cache2k configuration");
    }
    if (!config.getValueType().equals(Object.class) && !config.getValueType().equals(valueType.getType())) {
      throw new IllegalArgumentException("Value type mismatch between JCache and cache2k configuration");
    }
  }
22909
@Override
    public Set<CurrencyUnit> getCurrencies(CurrencyQuery query) {
        Set<CurrencyUnit> result = new HashSet<>();
        for (Locale locale : query.getCountries()) {
            try {
                result.add(Waehrung.of(Currency.getInstance(locale)));
            } catch (IllegalArgumentException ex) {
                LOG.log(Level.WARNING, "Cannot get currency for locale '" + locale + "':", ex);
            }
        }
        for (String currencyCode : query.getCurrencyCodes()) {
            try {
                result.add(Waehrung.of(currencyCode));
            } catch (IllegalArgumentException ex) {
                LOG.log(Level.WARNING, "Cannot get currency '" + currencyCode + "':", ex);
            }
        }
        for (CurrencyProviderSpi spi : Bootstrap.getServices(CurrencyProviderSpi.class)) {
            result.addAll(spi.getCurrencies(query));
        }
        return result;
    }
190953
public void setCurrencyDigits(Integer currDigs)
   {
      if (currDigs == null)
      {
         currDigs = DEFAULT_CURRENCY_DIGITS;
      }
      set(ProjectField.CURRENCY_DIGITS, currDigs);
   }
1199242
@Override
    public Set<Class<? extends MonetaryAmount>> getAmountTypes() {
        Set<Class<? extends MonetaryAmount>> amountTypes = new HashSet<>(factories.keySet());
        amountTypes.add(Geldbetrag.class);
        return amountTypes;
    }
947030
public void setCostType(com.google.api.ads.admanager.axis.v201902.CostType costType) {
        this.costType = costType;
    }
1072616
public static CurrencyUnit getCurrency(CurrencyQuery query) {
        return Optional.ofNullable(MONETARY_CURRENCIES_SINGLETON_SPI()).orElseThrow(
                () -> new MonetaryException("No MonetaryCurrenciesSingletonSpi loaded, check your system setup."))
                .getCurrency(query);
    }
1095264
public void setTypes(@NonNull String[] types) {
      this.types = Arrays.stream(types)
                         .map(Types::from)
                         .toArray(AnnotatableType[]::new);
   }