JAVAMONEY-97: Merged singletons into single Monetary singleton.

Author: atsticks

UserGuide.adoc

@@ -146,7 +146,7 @@ Since a corresponding +MonetaryAmountFactory+ is registered, a new instance can
 [source,java]
 .Example Usage of MonetaryAmountFactory
 -------------------------------------------------------------------
-MonetaryAmountFactory<Money> fact = MonetaryAmounts.getAmountFactory(Money.class);
+MonetaryAmountFactory<Money> fact = Monetary.getAmountFactory(Money.class);
 Money m = fact.withCurrency("USD").with(200.50).create();
 -------------------------------------------------------------------
 
@@ -156,7 +156,7 @@ default amount factory, which effective type instance is returned):
 [source,java]
 .Example Usage MonetaryAmountFactory
 -------------------------------------------------------------------
-MonetaryAmount amt = MonetaryAmounts.getDefaultAmountFactory()
+MonetaryAmount amt = Monetary.getDefaultAmountFactory()
                        .withCurrency("USD").with(200.50).create();
 -------------------------------------------------------------------
 
@@ -202,9 +202,9 @@ mentioned also external functionality can be chained, e.g. using instances of +M
 .Example Function Chaining footnote:[+MonetaryFunctions+ is not part of the JSR, its just for illustration purposes.]
 -------------------------------------------------------------------
 MonetaryAmount amt = ...;
-amt = amt.multiply(2.12345).with(MonetaryRoundings.getDefaultRounding())
+amt = amt.multiply(2.12345).with(Monetary.getDefaultRounding())
         .with(MonetaryFunctions.minimal(100)).
-        .multiply(2.12345).with(MonetaryRoundings.getDefaultRounding())
+        .multiply(2.12345).with(Monetary.getDefaultRounding())
         .with(MonetaryFunctions.percent(23));
 -------------------------------------------------------------------
 
@@ -217,7 +217,7 @@ When accessing +MonetaryAmountFactory+ instances it is possible to configure the
 [source,java]
 .Example Configuring a +MonetaryAmountFactory+, using the RI class +Money+ as example.
 -------------------------------------------------------------------
-MonetaryAmountFactory<Money> fact = MonetaryAmounts.getAmountFactory(
+MonetaryAmountFactory<Money> fact = Monetary.getAmountFactory(
    MonetaryAmountFactoryQueryBuilder.of(Money.class)
      .set(new MathContext(250, RoundingMode.HALF_DOWN)).build()
 );
@@ -269,7 +269,7 @@ just replacing +FastMoney+ with +Money+:
 [source,java]
 .Usage Example - FastMoney
 -------------------------------------------------------------------
-MonetaryAmountFactory<FastMoney> fact = MonetaryAmounts.getAmountFactory(FastMoney.class);
+MonetaryAmountFactory<FastMoney> fact = Monetary.getAmountFactory(FastMoney.class);
 // Creates an instance of Money with the given MathContext
 MonetaryAmount m1 = fact.setCurrency("CHF").setNumber(250.34).create();
 FastMoney m2 = fact.setCurrency("CHF").setNumber(250.34).create();
@@ -326,7 +326,7 @@ public class Total implements MonetaryOperator{
    }
 
    public <T extends MonetaryAmount> T getTotal(Class<T> amountType){
-      return MonetaryAmounts.getAmountFactory(amountType).with(total).create();
+      return Monetary.getAmountFactory(amountType).with(total).create();
    }
 
 }

src/main/java/javax/money/DefaultMonetaryCurrenciesSingletonSpi.java

@@ -0,0 +1,205 @@
+/*
+ * CREDIT SUISSE IS WILLING TO LICENSE THIS SPECIFICATION TO YOU ONLY UPON THE
+ * CONDITION THAT YOU ACCEPT ALL OF THE TERMS CONTAINED IN THIS AGREEMENT.
+ * PLEASE READ THE TERMS AND CONDITIONS OF THIS AGREEMENT CAREFULLY. BY
+ * DOWNLOADING THIS SPECIFICATION, YOU ACCEPT THE TERMS AND CONDITIONS OF THE
+ * AGREEMENT. IF YOU ARE NOT WILLING TO BE BOUND BY IT, SELECT THE "DECLINE"
+ * BUTTON AT THE BOTTOM OF THIS PAGE.
+ *
+ * Specification: JSR-354 Money and Currency API ("Specification")
+ *
+ * Copyright (c) 2012-2013, Credit Suisse All rights reserved.
+ */
+package javax.money;
+
+import javax.money.spi.Bootstrap;
+import javax.money.spi.CurrencyProviderSpi;
+import javax.money.spi.MonetaryCurrenciesSingletonSpi;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Factory singleton for {@link javax.money.CurrencyUnit} instances as provided by the
+ * different registered {@link javax.money.spi.CurrencyProviderSpi} instances.
+ * <p>
+ * This class is thread safe.
+ *
+ * @author Anatole Tresch
+ * @version 0.8
+ */
+final class DefaultMonetaryCurrenciesSingletonSpi implements MonetaryCurrenciesSingletonSpi {
+
+    @Override
+    public Set<CurrencyUnit> getCurrencies(CurrencyQuery query) {
+        Set<CurrencyUnit> result = new HashSet<CurrencyUnit>();
+        for (CurrencyProviderSpi spi : Bootstrap.getServices(CurrencyProviderSpi.class)) {
+            try {
+                result.addAll(spi.getCurrencies(query));
+            } catch (Exception e) {
+                Logger.getLogger(DefaultMonetaryCurrenciesSingletonSpi.class.getName())
+                        .log(Level.SEVERE, "Error loading currency provider names for " + spi.getClass().getName(),
+                                e);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * This default implementation simply returns all providers defined in arbitrary order.
+     *
+     * @return the default provider chain, never null.
+     */
+    @Override
+    public List<String> getDefaultProviderChain() {
+        List<String> list = new ArrayList<String>();
+        list.addAll(getProviderNames());
+        Collections.sort(list);
+        return list;
+    }
+
+    /**
+     * Get the names of the currently loaded providers.
+     *
+     * @return the names of the currently loaded providers, never null.
+     */
+    @Override
+    public Set<String> getProviderNames() {
+        Set<String> result = new HashSet<String>();
+        for (CurrencyProviderSpi spi : Bootstrap.getServices(CurrencyProviderSpi.class)) {
+            try {
+                result.add(spi.getProviderName());
+            } catch (Exception e) {
+                Logger.getLogger(DefaultMonetaryCurrenciesSingletonSpi.class.getName())
+                        .log(Level.SEVERE, "Error loading currency provider names for " + spi.getClass().getName(),
+                                e);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Access a new instance based on the currency code. Currencies are
+     * available as provided by {@link javax.money.spi.CurrencyProviderSpi} instances registered
+     * with the {@link javax.money.spi.Bootstrap}.
+     *
+     * @param currencyCode the ISO currency code, not {@code null}.
+     * @param providers    the (optional) specification of providers to consider. If not set (empty) the providers
+     *                     as defined by #getDefaultRoundingProviderChain() should be used.
+     * @return the corresponding {@link javax.money.CurrencyUnit} instance.
+     * @throws javax.money.UnknownCurrencyException if no such currency exists.
+     */
+    public CurrencyUnit getCurrency(String currencyCode, String... providers) {
+        Objects.requireNonNull(currencyCode, "Currency Code may not be null");
+        Collection<CurrencyUnit> found =
+                getCurrencies(CurrencyQueryBuilder.of().setCurrencyCodes(currencyCode).setProviderNames(providers).build());
+        if (found.isEmpty()) {
+            throw new UnknownCurrencyException(currencyCode);
+        }
+        if (found.size() > 1) {
+            throw new MonetaryException("Ambiguous CurrencyUnit for code: " + currencyCode + ": " + found);
+        }
+        return found.iterator().next();
+    }
+
+    /**
+     * Access a new instance based on the currency code. Currencies are
+     * available as provided by {@link javax.money.spi.CurrencyProviderSpi} instances registered
+     * with the {@link javax.money.spi.Bootstrap}.
+     *
+     * @param country   the ISO currency's country, not {@code null}.
+     * @param providers the (optional) specification of providers to consider. If not set (empty) the providers
+     *                  as defined by #getDefaultRoundingProviderChain() should be used.
+     * @return the corresponding {@link javax.money.CurrencyUnit} instance.
+     * @throws javax.money.UnknownCurrencyException if no such currency exists.
+     */
+    public CurrencyUnit getCurrency(Locale country, String... providers) {
+        Collection<CurrencyUnit> found =
+                getCurrencies(CurrencyQueryBuilder.of().setCountries(country).setProviderNames(providers).build());
+        if (found.isEmpty()) {
+            throw new MonetaryException("No currency unit found for locale: " + country);
+        }
+        if (found.size() > 1) {
+            throw new MonetaryException("Ambiguous CurrencyUnit for locale: " + country + ": " + found);
+        }
+        return found.iterator().next();
+    }
+
+    /**
+     * Provide access to all currently known currencies.
+     *
+     * @param locale    the target {@link java.util.Locale}, typically representing an ISO country,
+     *                  not {@code null}.
+     * @param providers the (optional) specification of providers to consider. If not set (empty) the providers
+     *                  as defined by #getDefaultRoundingProviderChain() should be used.
+     * @return a collection of all known currencies, never null.
+     */
+    public Set<CurrencyUnit> getCurrencies(Locale locale, String... providers) {
+        return getCurrencies(CurrencyQueryBuilder.of().setCountries(locale).setProviderNames(providers).build());
+    }
+
+    /**
+     * Allows to check if a {@link javax.money.CurrencyUnit} instance is defined, i.e.
+     * accessible from {@link javax.money.spi.MonetaryCurrenciesSingletonSpi#getCurrency(String, String...)}.
+     *
+     * @param code      the currency code, not {@code null}.
+     * @param providers the (optional) specification of providers to consider. If not set (empty) the providers
+     *                  as defined by #getDefaultRoundingProviderChain() should be used.
+     * @return {@code true} if {@link javax.money.spi.MonetaryCurrenciesSingletonSpi#getCurrency(String, String...)}
+     * would return a result for the given code.
+     */
+    public boolean isCurrencyAvailable(String code, String... providers) {
+        return !getCurrencies(CurrencyQueryBuilder.of().setCurrencyCodes(code).setProviderNames(providers).build())
+                .isEmpty();
+    }
+
+    /**
+     * Allows to check if a {@link javax.money.CurrencyUnit} instance is
+     * defined, i.e. accessible from {@link #getCurrency(String, String...)}.
+     *
+     * @param locale    the target {@link java.util.Locale}, not {@code null}.
+     * @param providers the (optional) specification of providers to consider. If not set (empty) the providers
+     *                  as defined by #getDefaultRoundingProviderChain() should be used.
+     * @return {@code true} if {@link #getCurrencies(java.util.Locale, String...)} would return a
+     * non empty result for the given code.
+     */
+    public boolean isCurrencyAvailable(Locale locale, String... providers) {
+        return !getCurrencies(CurrencyQueryBuilder.of().setCountries(locale).setProviderNames(providers).build()).isEmpty();
+    }
+
+    /**
+     * Provide access to all currently known currencies.
+     *
+     * @param providers the (optional) specification of providers to consider. If not set (empty) the providers
+     *                  as defined by #getDefaultRoundingProviderChain() should be used.
+     * @return a collection of all known currencies, never null.
+     */
+    public Set<CurrencyUnit> getCurrencies(String... providers) {
+        return getCurrencies(CurrencyQueryBuilder.of().setProviderNames(providers).build());
+    }
+
+    /**
+     * Access a single currency by query.
+     *
+     * @param query The currency query, not null.
+     * @return the {@link javax.money.CurrencyUnit} found, never null.
+     * @throws javax.money.MonetaryException if multiple currencies match the query.
+     */
+    public CurrencyUnit getCurrency(CurrencyQuery query) {
+        Set<CurrencyUnit> currencies = getCurrencies(query);
+        if (currencies.isEmpty()) {
+            return null;
+        }
+        if (currencies.size() == 1) {
+            return currencies.iterator().next();
+        }
+        throw new MonetaryException("Ambiguous request for CurrencyUnit: " + query + ", found: " + currencies);
+    }
+}