How to use

getCurrency

method

in

javax.money.convert.ExchangeRate

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

/**
 * 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;
}

  /**
   * 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 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;
}

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();
}

@Override
public int compareTo(ExchangeRate o) {
  if (o == null) {
    return -1;
  }
  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;
}

/**
 * Method that converts the source {@link MonetaryAmount} to an
 * {@link MonetaryAmount} based on the {@link ExchangeRate} of this
 * conversion.
 * @param amount The source amount
 * @return The converted amount, never null.
 * @throws CurrencyConversionException if conversion failed, or the required data is not available.
 * @see #getExchangeRate(MonetaryAmount)
 */
@Override
public MonetaryAmount apply(MonetaryAmount amount) {
  if (termCurrency.equals(Objects.requireNonNull(amount).getCurrency())) {
    return amount;
  }
  ExchangeRate rate = getExchangeRate(amount);
  if (Objects.isNull(rate) || !amount.getCurrency().equals(rate.getBaseCurrency())) {
    throw new CurrencyConversionException(amount.getCurrency(),
        this.termCurrency, null);
  }
  NumberValue factor = rate.getFactor();
  factor = roundFactor(amount, factor);
  Integer scale = rate.getContext().get(KEY_SCALE, Integer.class);
  if(Objects.isNull(scale) || scale < 0) {
    return amount.multiply(factor).getFactory().setCurrency(rate.getCurrency()).create();
  } else {
    return amount.multiply(factor).getFactory().setCurrency(rate.getCurrency()).create().with(MonetaryOperators.rounding(scale));
  }
}

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

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

/**
 * 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());
}

/**
 * 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());
}

/**
 * The method reverses the {@link ExchangeRate} to a rate mapping from term
 * to base {@link CurrencyUnit}. Hereby the factor must <b>not</b> be
 * recalculated as {@code 1/oldFactor}, since typically reverse rates are
 * not symmetric in most cases.
 *
 * @return the matching reversed {@link ExchangeRate}, or {@code null}, if
 * the rate cannot be reversed.
 */
default 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 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);
  }
}

/**
 * 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);
  }
}

/**
 * Compare conversions done with exchange rates provided for same currency pair.
 */
@Test(description = "4.3.2 Test correct ExchangeRate is returned for CHF -> FOO, using TestRateProvider.")
@SpecAssertion(id = "432-A2", section = "4.3.2")
public void testConversionComparedWithRate() {
  final CurrencyUnit FOO = new TestCurrencyUnit("FOO");
  ExchangeRate rate = MonetaryConversions.getExchangeRateProvider("TestRateProvider")
      .getExchangeRate(Monetary.getCurrency("CHF"), FOO);
  AssertJUnit.assertEquals(rate.getBaseCurrency(), Monetary.getCurrency("CHF"));
  AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO.getCurrencyCode());
  AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  AssertJUnit.assertEquals("TestRateProvider", rate.getContext().getProviderName());
}

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