import javax.money.convert.ConversionContext; //导入依赖的package包/类
@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.");
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@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));
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
public LazyBoundCurrencyConversion(ConversionQuery conversionQuery, ExchangeRateProvider rateProvider,
                                   ConversionContext conversionContext) {

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

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@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);
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@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());
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@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();
       }
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
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();
       }
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@Override
public CurrencyConversion getCurrencyConversion(ConversionQuery conversionQuery) {
    return new LazyBoundCurrencyConversion(conversionQuery, this, ConversionContext
            .of(getContext().getProviderName(), getContext().getRateTypes().iterator().next()));
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
public AbstractCurrencyConversion(CurrencyUnit termCurrency, ConversionContext conversionContext) {
    Objects.requireNonNull(termCurrency);
    Objects.requireNonNull(conversionContext);
    this.termCurrency = termCurrency;
    this.conversionContext = conversionContext;
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@Override
public CurrencyConversion with(ConversionContext conversionContext) {
    return new LazyBoundCurrencyConversion(conversionQuery, rateProvider,
            conversionContext);
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@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();
            Calendar timestamp = conversionQuery.get(Calendar.class);
            if (timestamp == null) {
                timestamp = conversionQuery.get(GregorianCalendar.class);
            }
            ExchangeRate rate1;
            ExchangeRate rate2;
            LocalDate localDate;
            if (timestamp == null) {
                localDate = LocalDate.yesterday();
                rate1 = lookupRate(currencyToSdr.get(base), localDate);
                rate2 = lookupRate(sdrToCurrency.get(term), localDate);
                if(rate1==null || rate2==null){
                    localDate = LocalDate.beforeDays(2);
                }
                rate1 = lookupRate(currencyToSdr.get(base), localDate);
                rate2 = lookupRate(sdrToCurrency.get(term), localDate);
                if(rate1==null || rate2==null){
                    localDate = LocalDate.beforeDays(3);
                    rate1 = lookupRate(currencyToSdr.get(base), localDate);
                    rate2 = lookupRate(sdrToCurrency.get(term), localDate);
                }
            }
            else{
                localDate = LocalDate.from(timestamp);
                rate1 = lookupRate(currencyToSdr.get(base), localDate);
                rate2 = lookupRate(sdrToCurrency.get(term), localDate);
            }
            if(rate1==null || rate2==null){
                return null;
            }
            if (base.equals(SDR)) {
                return rate2;
            } else if (term.equals(SDR)) {
                return rate1;
            }
            ExchangeRateBuilder builder =
                    new ExchangeRateBuilder(ConversionContext.of(CONTEXT.getProviderName(), RateType.HISTORIC));
            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);
    }
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@Override
public ConversionContext getContext() {
    return null;
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@Test(expectedExceptions  = NullPointerException.class)
public void shouldReturnNPEWhenConversionContextIsNull() {
	ConversionContext context = null;
	new ExchangeRateBuilder(context).setBase(CURRENCY)
			.setTerm(CURRENCY).setFactor(NUMBER_FACTOR).build();
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@Test(expectedExceptions  = NullPointerException.class)
public void shouldReturnNPEWhenTermIsNull() {
	new ExchangeRateBuilder(ConversionContext.ANY_CONVERSION).setBase(CURRENCY)
			.setTerm(null).setFactor(NUMBER_FACTOR).build();
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@Test(expectedExceptions  = NullPointerException.class)
public void shouldReturnNPEWhenBaseIsNull() {
	new ExchangeRateBuilder(ConversionContext.ANY_CONVERSION).setBase(null)
			.setTerm(CURRENCY).setFactor(NUMBER_FACTOR).build();
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@Test(expectedExceptions  = NullPointerException.class)
public void shouldReturnNPEWhenFactorIsNull() {
	new ExchangeRateBuilder(ConversionContext.ANY_CONVERSION).setBase(CURRENCY)
			.setTerm(CURRENCY).setFactor(null).build();
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
@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);
    }
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
/**
 * 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));
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
/**
 * 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;
}
 

import javax.money.convert.ConversionContext; //导入依赖的package包/类
/**
 * Access the {@link javax.money.convert.ConversionContext} of {@link javax.money.convert.ExchangeRate}.
 *
 * @return the conversion context, never null.
 */
public final ConversionContext getContext() {
    return this.conversionContext;
}