How to use

ExchangeRate

in

javax.money.convert

/**
 * Initialize the {@link ExchangeRateBuilder} with an {@link javax.money.convert.ExchangeRate}. This is
 * useful for creating a new rate, reusing some properties from an
 * existing one.
 *
 * @param rate the base rate
 * @return the Builder, for chaining.
 */
public ExchangeRateBuilder setRate(ExchangeRate rate) {
  this.base = rate.getBaseCurrency();
  this.term = rate.getCurrency();
  this.conversionContext = rate.getContext();
  this.factor = rate.getFactor();
  this.rateChain = rate.getExchangeRateChain();
  this.term = rate.getCurrency();
  return this;
}

/**
 * @param rate specifies the base and target currencies
 */
public CurrencyUnitPair(ExchangeRate rate) {
  this(rate.getBaseCurrency(), rate.getCurrency());
}

@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;
}

private ExchangeRate reverse(ExchangeRate rate) {
  if (Objects.isNull(rate)) {
    throw new IllegalArgumentException("Rate null is not reversible.");
  }
  return new ExchangeRateBuilder(rate).setRate(rate).setBase(rate.getCurrency()).setTerm(rate.getBaseCurrency())
      .setFactor(divide(DefaultNumberValue.ONE, rate.getFactor(), MathContext.DECIMAL64)).build();
}

private ExchangeRate createExchangeRate(ConversionQuery query,
                    ExchangeRateBuilder builder, ExchangeRate sourceRate,
                    ExchangeRate target) {
  if (areBothBaseCurrencies(query)) {
    builder.setFactor(DefaultNumberValue.ONE);
    return builder.build();
  } else if (BASE_CURRENCY_CODE.equals(query.getCurrency().getCurrencyCode())) {
    if (Objects.isNull(sourceRate)) {
      return null;
    }
    return reverse(sourceRate);
  } else if (BASE_CURRENCY_CODE.equals(query.getBaseCurrency()
      .getCurrencyCode())) {
    return target;
  } else {
    ExchangeRate rate1 = getExchangeRate(
        query.toBuilder().setTermCurrency(Monetary.getCurrency(BASE_CURRENCY_CODE)).build());
    ExchangeRate rate2 = getExchangeRate(
        query.toBuilder().setBaseCurrency(Monetary.getCurrency(BASE_CURRENCY_CODE))
            .setTermCurrency(query.getCurrency()).build());
    if (Objects.nonNull(rate1) && Objects.nonNull(rate2)) {
      builder.setFactor(multiply(rate1.getFactor(), rate2.getFactor()));
      builder.setRateChain(rate1, rate2);
      return builder.build();
    }
    throw new CurrencyConversionException(query.getBaseCurrency(),
        query.getCurrency(), sourceRate.getContext());
  }
}

/**
 * Test correct rate evaluation for different provider chains, providers defined by the TCK.<p>
 * Hint do not use non TCK provider for this test, it will make results undeterministic.
 */
@Test(description = "4.3.4 Test correct rate evaluation for different conversion provider chains, " +
    "with duplicate provider entries.")
@SpecAssertion(id = "434-A1", section = "4.3.4")
public void testCorrectRateEvaluationInChain_sameProviders() {
  ExchangeRateProvider prov1 = MonetaryConversions
      .getExchangeRateProvider("TestRateProvider1", "TestRateProvider1", "TestRateProvider1");
  ExchangeRate rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
  prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider1", "TestRateProvider1");
  rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
  prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider1");
  rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
}

/**
 * Ensure additional ConversionContext is passed correctly to SPIs.<p>
 * Hint: this assertion will require some custom SPIs to be registered and selected for chain inclusion!
 */
@Test(description = "4.3.3 Ensure additional ConversionQuery data is passed correctly to SPIs.")
@SpecAssertion(id = "433-A2", section = "4.3.3")
public void testPassingOverConversionContextToSPIs() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  ConversionQuery ctx = ConversionQueryBuilder.of().set(Locale.CANADA).set("Foo", "bar").setBaseCurrency(FOO_UNIT)
      .setTermCurrency(Monetary.getCurrency("XXX")).build();
  ExchangeRate rate = prov.getExchangeRate(ctx);
  AssertJUnit.assertNotNull("No test rate returned by getExchangeRate(ConversionQuery), " +
      "probably TestProvider is not correct registered.");
  AssertJUnit.assertEquals(
      "Text parameter Locale.class was not correctly passed to ExchangeRateProvider implementation.", "bar",
      rate.getContext().getText("Foo"));
  AssertJUnit.assertEquals(
      "Object parameter Locale.class was not correctly passed to ExchangeRateProvider implementation.",
      Locale.CANADA, rate.getContext().get(Locale.class));
}

/**
 * Allows to evaluate if this exchange rate is a derived exchange rate.
 * Derived exchange rates are defined by an ordered list of subconversions
 * with intermediate steps, whereas a direct conversion is possible in one
 * steps.
 * <p>
 * This method always returns {@code true}, if the chain contains more than
 * one rate. Direct rates, have also a chain, but with exact one rate.
 *
 * @return true, if the exchange rate is derived.
 */
default boolean isDerived() {
  return getExchangeRateChain().size() > 1;
}

@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;
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access of Conversion Rates, using TCK provided rate provider.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRates() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    if (base.equals(FOO_UNIT)) {
      continue;
    }
    ExchangeRate rate = prov.getExchangeRate(base, FOO_UNIT);
    AssertJUnit.assertNotNull(
        "Identity rate, accessed by getExchangeRate(CurrencyUnit, CurrencyUnit), is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}

/**
 * Test correct rate evaluation for different provider chains, providers defined by the TCK,
 * with historic rates.<p>
 * Hint do not use non TCK provider for this test, it will make results undeterministic.
 */
@Test(description = "4.3.4 Test correct rate evaluation for different conversion provider chains, " +
    "with historic rates.")
@SpecAssertion(id = "434-A2", section = "4.3.4")
public void testCorrectRateEvaluationInChainHistoric() {
  ExchangeRateProvider prov1 = MonetaryConversions
      .getExchangeRateProvider("TestRateProvider1", "TestRateProvider2", "TestRateProvider3");
  ExchangeRate rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
  rate = prov1.getExchangeRate("EUR", "USD");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 2);
  Calendar cal = GregorianCalendar.getInstance();
  cal.setTimeInMillis(0L);
  rate = prov1.getExchangeRate(
      ConversionQueryBuilder.of()
          .set(cal)
          .setBaseCurrency("EUR")
          .setTermCurrency("USD")
          .build());
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", 2, rate.getFactor().intValueExact());
}

  /**
   * Initialize the {@link Builder} with an {@link javax.money.convert.ExchangeRate}. This is
   * useful for creating a new rate, reusing some properties from an
   * existing one.
   *
   * @param rate the base rate
   * @return the Builder, for chaining.
   */
  public Builder setRate(ExchangeRate rate) {
    this.base = rate.getBaseCurrency();
    this.term = rate.getCurrency();
    this.conversionContext = rate.getContext();
    this.factor = rate.getFactor();
    this.rateChain = rate.getExchangeRateChain();
    this.term = rate.getCurrency();
    return 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;
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access to exchange rates from TestRateProvider, using target currency code.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRatesWithCodes() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    if (base.equals(FOO_UNIT)) {
      continue;
    }
    ExchangeRate rate = prov.getExchangeRate(base.getCurrencyCode(), "XXX");
    AssertJUnit
        .assertNotNull("Identity rate, accessed by getExchangeRate(String, String), is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode(), rate);
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), "FOO");
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}

    .getExchangeRateProvider("TestRateProvider1", "TestRateProvider2", "TestRateProvider3");
ExchangeRate rate = prov1.getExchangeRate("CHF", "EUR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider1", "TestRateProvider2");
rate = prov1.getExchangeRate("EUR", "USD");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 2);
prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider3");
rate = prov1.getExchangeRate("USD", "INR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 3);
prov1 = MonetaryConversions
    .getExchangeRateProvider("TestRateProvider1", "TestRateProvider3", "TestRateProvider2");
rate = prov1.getExchangeRate("CHF", "EUR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
rate = prov1.getExchangeRate("EUR", "USD");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 2);
rate = prov1.getExchangeRate("USD", "INR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 3);
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
prov1 = MonetaryConversions
    .getExchangeRateProvider("TestRateProvider2", "TestRateProvider1", "TestRateProvider3");
rate = prov1.getExchangeRate("EUR", "USD");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 2);
rate = prov1.getExchangeRate("USD", "INR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 3);
        "TestRateProvider02");
rate = prov1.getExchangeRate("CHF", "EUR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);

/**
 * Sets the exchange rate type
 *
 * @param rate the {@link javax.money.convert.ExchangeRate} to be applied
 */
public ExchangeRateBuilder(ExchangeRate rate) {
  setContext(rate.getContext());
  setFactor(rate.getFactor());
  setTerm(rate.getCurrency());
  setBase(rate.getBaseCurrency());
  setRateChain(rate.getExchangeRateChain());
}

@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;
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access to exchange rates from TestRateProvider, using target CUrrencyUnit.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRatesAndContext() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    if (base.equals(FOO_UNIT)) {
      continue;
    }
    ExchangeRate rate = prov.getExchangeRate(base, FOO_UNIT);
    AssertJUnit.assertNotNull(
        "Identity rate, accessed by getExchangeRate(CurrencyUnit, CurrencyUnit, ConversionContext), " +
            "is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}

/**
 * Sets the exchange rate type
 *
 * @param rate the {@link javax.money.convert.ExchangeRate} to be applied
 */
public Builder(ExchangeRate rate) {
  setContext(rate.getContext());
  setFactor(rate.getFactor());
  setTerm(rate.getCurrency());
  setBase(rate.getBaseCurrency());
  setRateChain(rate.getExchangeRateChain());
}

@Override
public int compareTo(ExchangeRate o) {
  Objects.requireNonNull(o);
  int compare = this.getBaseCurrency().getCurrencyCode().compareTo(o.getBaseCurrency().getCurrencyCode());
  if (compare == 0) {
    compare = this.getCurrency().getCurrencyCode().compareTo(o.getCurrency().getCurrencyCode());
  }
  if (compare == 0) {
    compare = this.getContext().getProviderName().compareTo(o.getContext().getProviderName());
  }
  return compare;
}