How to use javax.money.convert

/**
 * Access a {@link CurrencyConversion} that can be applied as a
 * {@link MonetaryOperator} to an amount.
 *
 * @param term term {@link CurrencyUnit}, not {@code null}
 * @return a new instance of a corresponding {@link CurrencyConversion},
 * never {@code null}.
 */
default CurrencyConversion getCurrencyConversion(CurrencyUnit term){
  return getCurrencyConversion(ConversionQueryBuilder.of().setTermCurrency(term).build());
}

/**
 * Checks if an {@link ExchangeRate} between two {@link CurrencyUnit} is
 * available from this provider. This method should check, if a given rate
 * is <i>currently</i> defined.
 *
 * @param base the base {@link CurrencyUnit}
 * @param term the term {@link CurrencyUnit}
 * @return {@code true}, if such an {@link ExchangeRate} is currently
 * defined.
 */
default boolean isAvailable(CurrencyUnit base, CurrencyUnit term){
  return isAvailable(ConversionQueryBuilder.of().setBaseCurrency(base).setTermCurrency(term).build());
}

/**
 * Creates a query builder based on this onctex.
 *
 * @return a new instance of {@link ConversionQueryBuilder}, never null.
 */
public ConversionQueryBuilder toQueryBuilder() {
  return ConversionQueryBuilder.of().importContext(this);
}

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

protected ConversionContext getExchangeContext(String key) {
  int scale = getScale(key);
  if(scale < 0) {
   return ConversionContext.of(this.context.getProviderName(), RateType.HISTORIC);
  } else {
    return ConversionContext.of(this.context.getProviderName(), RateType.HISTORIC).toBuilder().set(KEY_SCALE, scale).build();
  }
}

/**
 * Sets the exchange rate type
 *
 * @param rateType the {@link javax.money.convert.RateType} contained
 */
public ExchangeRateBuilder(String provider, RateType rateType) {
  this(ConversionContext.of(provider, rateType));
}

/**
 * Create a new Builder instance without any provider, e.g. for creating
 * new {@link ConversionContext} instances for querying.
 */
public ConversionContextBuilder() {
  set(RateType.ANY);
}

/**
 * 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.
 */
public ConversionQueryBuilder setRateTypes(Set<RateType> rateTypes) {
  return set(ConversionQuery.KEY_RATE_TYPES, rateTypes);
}

/**
 * Creates a new {@link javax.money.convert.ConversionQueryBuilder} instance.
 *
 * @param query the {@link javax.money.convert.ConversionQuery} instance to be used as a template.
 * @return a new {@link javax.money.convert.ConversionQueryBuilder} instance, never null.
 */
public static ConversionQueryBuilder of(ConversionQuery query) {
  return new ConversionQueryBuilder().importContext(query);
}

/**
 * Get the provider of this rate. The provider of a rate can have different
 * contexts in different usage scenarios, such as the service type or the
 * stock exchange.
 *
 * @return the provider, or {code null}.
 */
public String getProviderName() {
  return getText("provider");
}

/**
 * Creates a new {@link javax.money.convert.ConversionContextBuilder} instance.
 *
 * @return a new {@link javax.money.convert.ConversionContextBuilder} instance, never null.
 */
public static ConversionContextBuilder of() {
  return new ConversionContextBuilder();
}

/**
 * Create a new ProviderContextBuilder, hereby using the given {@link ProviderContext}
 * 's values as defaults. This allows changing an existing
 * {@link ProviderContext} easily.
 *
 * @param context the context, not {@code null}
 * @return a new {@link javax.money.convert.ProviderContextBuilder} instance, never null.
 */
public static ProviderContextBuilder create(ProviderContext context) {
  return new ProviderContextBuilder(context);
}

/**
 * Creates a new {@link javax.money.convert.ConversionQueryBuilder} instance.
 *
 * @return a new {@link javax.money.convert.ConversionQueryBuilder} instance, never null.
 */
public static ConversionQueryBuilder of() {
  return new ConversionQueryBuilder();
}

/**
 * Creates a new {@link ConversionContext} with the data from this
 * Builder instance.
 *
 * @return a new {@link ConversionContext}. never {@code null}.
 */
public ConversionContext build() {
  return new ConversionContext(this);
}

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

/**
 * Sets the exchange rate type
 *
 * @param rateType the {@link javax.money.convert.RateType} contained
 */
public Builder(String provider, RateType rateType) {
  this(ConversionContext.of(provider, rateType));
}

/**
 * Sets the base currency.
 *
 * @param currency the base currency
 * @return the query for chaining.
 */
public ConversionQueryBuilder setBaseCurrency(CurrencyUnit currency) {
  return set(ConversionQuery.KEY_BASE_CURRENCY, currency);
}

/**
 * Creates a new {@link javax.money.convert.ConversionContextBuilder} instance.
 * @param conversionContext the conversion context to be used to initialize the new builder instance, not null.
 * @return a new {@link javax.money.convert.ConversionContextBuilder} instance, never null.
 */
public static ConversionContextBuilder of(ConversionContext conversionContext) {
  return new ConversionContextBuilder(conversionContext);
}

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}