org.javamoney.moneta.spi.DefaultNumberValue Java Examples

private void addRate(CurrencyUnit term, LocalDate localDate, Number rate, boolean inverse) {
    RateType rateType = RateType.HISTORIC;
    ExchangeRateBuilder builder =
        new ExchangeRateBuilder(ConversionContextBuilder.create(context, rateType).set(localDate).build());
    builder.setBase(inverse ? term : USFederalReserveRateProvider.BASE_CURRENCY);
    builder.setTerm(inverse ? USFederalReserveRateProvider.BASE_CURRENCY : term);
    builder.setFactor(DefaultNumberValue.of(rate));
    ExchangeRate exchangeRate = builder.build();
    if(inverse) {
        exchangeRate = USFederalReserveRateProvider.reverse(exchangeRate);
    }
    Map<String, ExchangeRate> rateMap = this.historicRates.get(localDate);
    if (Objects.isNull(rateMap)) {
        synchronized (this.historicRates) {
            rateMap = Optional.ofNullable(this.historicRates.get(localDate)).orElse(new ConcurrentHashMap<>());
            this.historicRates.putIfAbsent(localDate, rateMap);
        }
    }
    rateMap.put(term.getCurrencyCode(), exchangeRate);
}
 

private void addRate(YahooQuoteItemInformation information) {

        final ExchangeRateBuilder builder = new ExchangeRateBuilder(
        		ConversionContextBuilder.create(context, RateType.DEFERRED).build());
        builder.setBase(YahooAbstractRateProvider.BASE_CURRENCY);
        builder.setTerm(information.getCurrency());
        builder.setFactor(DefaultNumberValue.of(information.getValue()));
        final ExchangeRate exchangeRate = builder.build();

        Map<String, ExchangeRate> rateMap = this.excangeRates.get(information.getLocalDate());
        if (Objects.isNull(rateMap)) {
            synchronized (this.excangeRates) {
                rateMap = Optional.ofNullable(this.excangeRates.get(information.getLocalDate())).orElse(new ConcurrentHashMap<>());
                this.excangeRates.putIfAbsent(information.getLocalDate(), rateMap);
            }
        }
        rateMap.put(information.getCurrency().getCurrencyCode(), exchangeRate);

    }
 

@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.");
}
 

public ExchangeRateUpdate tickerMapper(Ticker ticker) {
    Date timestamp = ticker.getTimestamp();
    long time = (timestamp != null) ? timestamp.getTime() : 0;
    return new ExchangeRateUpdate(pair,
            DefaultNumberValue.of(ticker.getBid()),
            time);
}
 

private ExchangeRate buildExchangeRate(CurrencyUnitPair pair, Ticker ticker) {
    return new ExchangeRateBuilder(name, RateType.DEFERRED)
            .setBase(pair.getBase())
            .setTerm(pair.getTarget())
            .setFactor(DefaultNumberValue.of(ticker.getLast()))
            .build();
}
 

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

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

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()).setContext(getExchangeContext(DIGIT_FRACTION_KEY))
            .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
public void equalsTest() {
	DefaultNumberValue factor = new DefaultNumberValue(1.1);
	DefaultNumberValue bigDecimalFactor = new DefaultNumberValue(new BigDecimal("1.1"));
	CurrencyUnit EUR = Monetary.getCurrency("EUR");
	CurrencyUnit GBP = Monetary.getCurrency("GBP");
	ExchangeRate rate1 = new ExchangeRateBuilder("myprovider", RateType.ANY)
			.setBase(EUR)
			.setTerm(GBP)
			.setFactor(factor)
			.build();

	ExchangeRate rate2 = new ExchangeRateBuilder("myprovider", RateType.ANY)
			.setBase(EUR)
			.setTerm(GBP)
			.setFactor(factor)
			.build();

	ExchangeRate rate3 = new ExchangeRateBuilder("myprovider", RateType.ANY)
			.setBase(EUR)
			.setTerm(GBP)
			.setFactor(bigDecimalFactor)
			.build();

	assertEquals(rate1, rate2, "Rates with same factor");
	assertEquals(rate1, rate3, "Rates with numerically equal factor");
	assertEquals(rate1.hashCode(), rate2.hashCode(), "Hashes with same factor");
	assertEquals(rate1.hashCode(), rate3.hashCode(), "Hashes with numerically equal factor");
}
 

@Test
public void equalsTest() {
    DefaultNumberValue factor = new DefaultNumberValue(1.1);
    DefaultNumberValue bigDecimalFactor = new DefaultNumberValue(new BigDecimal("1.1"));

    ExchangeRate rate1 = new ExchangeRateBuilder("myprovider", RateType.ANY)
            .setBase(EUR)
            .setTerm(GBP)
            .setFactor(factor)
            .build();

    ExchangeRate rate2 = new ExchangeRateBuilder("myprovider", RateType.ANY)
            .setBase(EUR)
            .setTerm(GBP)
            .setFactor(factor)
            .build();

    ExchangeRate rate3 = new ExchangeRateBuilder("myprovider", RateType.ANY)
            .setBase(EUR)
            .setTerm(GBP)
            .setFactor(bigDecimalFactor)
            .build();

    assertEquals(rate1, rate2, "Rates with same factor");
    assertEquals(rate1, rate3, "Rates with numerically equal factor");
    assertEquals(rate1.hashCode(), rate2.hashCode(), "Hashes with same factor");
    assertEquals(rate1.hashCode(), rate3.hashCode(), "Hashes with numerically equal factor");
}
 

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
    if (rate.getContext().getProviderName().equals(CONTEXT.getProviderName())) {
        return new ExchangeRateBuilder(rate.getContext()).setTerm(rate.getBaseCurrency())
                .setBase(rate.getCurrency()).setFactor(new DefaultNumberValue(BigDecimal.ONE)).build();
    }
    return null;
}
 

@Override
public ExchangeRate getExchangeRate(ConversionQuery conversionQuery) {
       if (conversionQuery.getBaseCurrency().getCurrencyCode().equals(conversionQuery.getCurrency().getCurrencyCode())) {
           ExchangeRateBuilder builder = new ExchangeRateBuilder(getContext().getProviderName(), RateType.OTHER)
                   .setBase(conversionQuery.getBaseCurrency());
           builder.setTerm(conversionQuery.getCurrency());
           builder.setFactor(DefaultNumberValue.of(BigDecimal.ONE));
           return builder.build();
       }
       return null;
   }
 

private ExchangeRateUpdate tickerToUpdate(CurrencyUnitPair pair, Ticker ticker) {
    return (ticker != null) ?
            new ExchangeRateUpdate(pair, DefaultNumberValue.of(ticker.getBid()), ticker.getTimestamp().getTime()) :
            new ExchangeRateUpdate(pair, null, 0);
}
 

@Override
public NumberValue getNumber() {
    return new DefaultNumberValue(number);
}
 

/**
 * Gets the number representation of the numeric value of this item.
 *
 * @return The {@link Number} representation matching best.
 */
@Override
public NumberValue getNumber() {
    return new DefaultNumberValue(getBigDecimal());
}
 

/**
 * Gets the number representation of the numeric value of this item.
 *
 * @return The {@link Number} representation matching best.
 */
@Override
public NumberValue getNumber() {
    return new DefaultNumberValue(number);
}
 

/**
 * Gets the percentage of the amount.
 * @param number to be used in percent
 * @see #percent(BigDecimal)}
 * @return the percent of {@link MonetaryOperator}
 */
public static MonetaryOperator percent(Number number) {
    return percent(new DefaultNumberValue(number).numberValue(BigDecimal.class));
}
 

/**
 * Returns the {@link #percent(BigDecimal)} converting
 * this number to {@link BigDecimal} and using the {@link MathContext} in parameters
 * @param number to be converted to {@link BigDecimal}
 * @param mathContext the mathContext to be used
 * @see #permil(BigDecimal)
 * @return the permil {@link MonetaryOperator}
 */
public static MonetaryOperator permil(Number number, MathContext mathContext) {
    return new PermilOperator(new DefaultNumberValue(number).numberValue(BigDecimal.class));
}
 

/**
 * Create an ExchangeRateValue for "unknown" exchange rate (no data yet)
 *
 * @param pair Exchange pair we don't have information on
 * @return An ExchangeRateUpdate with "unknown" values
 */
public static ExchangeRateUpdate unknown(CurrencyUnitPair pair) {
    return new ExchangeRateUpdate(pair, DefaultNumberValue.of(0), 0);
}