javax.money.convert.ConversionContext Java Examples

@Test
public void testNumberInsignificanceForRates(){
	ExchangeRate rateFromString = new ExchangeRateBuilder(ConversionContext.HISTORIC_CONVERSION)
			.setBase(Monetary.getCurrency("USD"))
			.setTerm(Monetary.getCurrency("EUR"))
			.setFactor(DefaultNumberValue.of(new BigDecimal("1.1")))
			.build();

	ExchangeRate rateFromDouble = new ExchangeRateBuilder(ConversionContext.HISTORIC_CONVERSION)
			.setBase(Monetary.getCurrency("USD"))
			.setTerm(Monetary.getCurrency("EUR"))
			.setFactor(DefaultNumberValue.of(1.1))
			.build();

	assertEquals(rateFromDouble, rateFromString, "Rates are not equal for same factor.");
}
 

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

@Override
public CurrencyConversion getCurrencyConversion(ConversionQuery conversionQuery) {
    if (getContext().getRateTypes().size() == 1) {
        return new LazyBoundCurrencyConversion(conversionQuery, this, ConversionContext
                .of(getContext().getProviderName(), getContext().getRateTypes().iterator().next()));
    }
    return new LazyBoundCurrencyConversion(conversionQuery, this,
            ConversionContext.of(getContext().getProviderName(), RateType.ANY));
}
 

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

public LazyBoundCurrencyConversion(ConversionQuery conversionQuery, ExchangeRateProvider rateProvider,
                                   ConversionContext conversionContext) {

    super(conversionQuery.getCurrency(), conversionContext);
    this.conversionQuery = conversionQuery;
    this.rateProvider = rateProvider;
}
 

@Test
public void shouldCreateExchangeRateFromExchangeRate() {
	ExchangeRate rate = new ExchangeRateBuilder(ConversionContext.ANY_CONVERSION).setBase(CURRENCY)
			.setTerm(CURRENCY).setFactor(NUMBER_FACTOR).build();

	ExchangeRate rate2 = new ExchangeRateBuilder(rate).build();

	assertEquals(rate.getContext(), rate2.getContext());
	assertEquals(rate.getBaseCurrency(), rate2.getBaseCurrency());
	assertEquals(rate.getFactor(), rate2.getFactor());
}
 

@Test
public void shouldCreateExchangeRate() {
	ExchangeRate rate = new ExchangeRateBuilder(ConversionContext.ANY_CONVERSION).setBase(CURRENCY)
			.setTerm(CURRENCY).setFactor(NUMBER_FACTOR).build();

	assertEquals(rate.getContext(), ConversionContext.ANY_CONVERSION);
	assertEquals(rate.getBaseCurrency(), CURRENCY);
	assertEquals(rate.getFactor(), NUMBER_FACTOR);
}
 

@Test(expectedExceptions  = NullPointerException.class)
public void shouldReturnNPEWhenTermIsNull() {
	new ExchangeRateBuilder(ConversionContext.ANY_CONVERSION).setBase(CURRENCY)
			.setTerm(null).setFactor(NUMBER_FACTOR).build();
}
 

@Test(expectedExceptions  = NullPointerException.class)
public void shouldReturnNPEWhenConversionContextIsNull() {
	ConversionContext context = null;
	new ExchangeRateBuilder(context).setBase(CURRENCY)
			.setTerm(CURRENCY).setFactor(NUMBER_FACTOR).build();
}
 

@Override
public ConversionContext getContext() {
    return null;
}
 

@Test(expectedExceptions  = NullPointerException.class)
public void shouldReturnNPEWhenBaseIsNull() {
	new ExchangeRateBuilder(ConversionContext.ANY_CONVERSION).setBase(null)
			.setTerm(CURRENCY).setFactor(NUMBER_FACTOR).build();
}
 

@Test(expectedExceptions  = NullPointerException.class)
public void shouldReturnNPEWhenFactorIsNull() {
	new ExchangeRateBuilder(ConversionContext.ANY_CONVERSION).setBase(CURRENCY)
			.setTerm(CURRENCY).setFactor(null).build();
}
 

@Override
public CurrencyConversion with(ConversionContext conversionContext) {
    return new LazyBoundCurrencyConversion(conversionQuery, rateProvider,
            conversionContext);
}
 

@Override
public ExchangeRate getExchangeRate(ConversionQuery conversionQuery) {
    try {
        if (loadLock.await(30, TimeUnit.SECONDS)) {
            if (currencyToSdr.isEmpty()) {
                return null;
            }
            if (!isAvailable(conversionQuery)) {
                return null;
            }
            CurrencyUnit base = conversionQuery.getBaseCurrency();
            CurrencyUnit term = conversionQuery.getCurrency();
            LocalDate[] times = getQueryDates(conversionQuery);
            ExchangeRate rate1 = getExchangeRate(currencyToSdr.get(base), times);
            ExchangeRate rate2 = getExchangeRate(sdrToCurrency.get(term), times);
            if (base.equals(SDR)) {
                return rate2;
            } else if (term.equals(SDR)) {
                return rate1;
            }
            if (Objects.isNull(rate1) || Objects.isNull(rate2)) {
                return null;
            }

            ConversionContext context = getExchangeContext("imf.digit.fraction");

            ExchangeRateBuilder builder =
                    new ExchangeRateBuilder(context);
            builder.setBase(base);
            builder.setTerm(term);
            builder.setFactor(multiply(rate1.getFactor(), rate2.getFactor()));
            builder.setRateChain(rate1, rate2);

            return builder.build();
        }else{
            // Lets wait for a successful load only once, then answer requests as data is present.
            loadLock.countDown();
            throw new MonetaryException("Failed to load currency conversion data: " + loadState);
        }
    }
    catch(InterruptedException e){
        throw new MonetaryException("Failed to load currency conversion data: Load task has been interrupted.", e);
    }
}
 

@Override
public CurrencyConversion getCurrencyConversion(ConversionQuery conversionQuery) {
    return new LazyBoundCurrencyConversion(conversionQuery, this, ConversionContext
            .of(getContext().getProviderName(), getContext().getRateTypes().iterator().next()));
}
 

public AbstractCurrencyConversion(CurrencyUnit termCurrency, ConversionContext conversionContext) {
    Objects.requireNonNull(termCurrency);
    Objects.requireNonNull(conversionContext);
    this.termCurrency = termCurrency;
    this.conversionContext = conversionContext;
}
 

/**
 * Evaluate the current default Conversion Context.
 *
 * @param src the source/base {@link javax.money.CurrencyUnit}, not null
 * @param tgt the target {@link javax.money.CurrencyUnit}, not null
 * @return the converted amount, not null.
 * @see javax.money.convert.MonetaryConversions
 * @see javax.money.convert.CurrencyConversion
 * @see javax.money.MonetaryOperator
 */
public ConversionContext getDefaultConversionContext(CurrencyUnit src, CurrencyUnit tgt) {
    throw new UnsupportedOperationException();
}
 

/**
    * Access the {@link javax.money.convert.ConversionContext} of {@link javax.money.convert.ExchangeRate}.
    *
    * @return the conversion context, never null.
    */
   @Override
public final ConversionContext getContext() {
       return this.conversionContext;
   }
 

/**
 * Sets the provider to be applied.
 *
 * @param conversionContext the {@link javax.money.convert.ConversionContext}, not null.
 * @return The builder.
 */
public ExchangeRateBuilder setContext(ConversionContext conversionContext) {
    Objects.requireNonNull(conversionContext);
    this.conversionContext = conversionContext;
    return this;
}
 

/**
 * Sets the exchange rate type
 *
 * @param context the {@link javax.money.convert.ConversionContext} to be applied
 */
public ExchangeRateBuilder(ConversionContext context) {
    setContext(context);
}
 

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

/**
 * Access the target {@link ConversionContext} of this conversion instance.
 *
 * @return the target {@link ConversionContext}.
 */
@Override
public ConversionContext getContext() {
    return conversionContext;
}
 

public abstract CurrencyConversion with(ConversionContext conversionContext);