JAVAMONEY-97: Merged singletons into single Monetary singleton.

Author: atsticks

src/main/JEP/MoneyAndCurrency.md

@@ -71,8 +71,7 @@ Summarizing the JSR contains the following main artifacts:
 
 * Interfaces for amounts (``MonetaryAmount``), currencies (``CurrencyUnit``), rounding (``MonetaryRounding``),
   conversion (``CurrencyConverter, ExchangeRateprovider``) and formatting (``MonetaryAmountFormat``).
-* Corresponding singleton accessors (``MonetaryCurrencies, MonetaryAmounts, MonetaryRoundings,
-  MonetaryConversions, MonetaryFormats``).
+* Corresponding singleton accessors (``Monetary, MonetaryConversions, MonetaryFormats``).
 * The singleton accessors are backed up by SPI interfaces (``MonetaryCurrenciesSingletonSpi,
   MonetaryAmountsSingletonSpi, MonetaryRoundingsSingletonSpi, MonetaryConversionSingletonSpi,
   MonetaryFormatsSingletonSpi``).
@@ -116,13 +115,13 @@ To give some first impressions of the API the following sections give some examp
 
 The class ``org.javamoney.moneta.Money`` implements ``MonetaryAmount`` using ``java.math.BigDecimal`` internally:
 
-    MonetaryAmountFactory<Money> fact = MonetaryAmounts.getAmountFactory(Money.class);
+    MonetaryAmountFactory<Money> fact = Monetary.getAmountFactory(Money.class);
     Money m = fact.setCurrency("USD").setNumber(200.50).create();
 
 Also a generic MonetaryAmount instance can be accessed using a raw factory (hereby it depends on the
 configured default amount factory, which effective type instance is returned):
 
-    MonetaryAmount amt = MonetaryAmounts.getDefaultAmountFactory()
+    MonetaryAmount amt = Monetary.getDefaultAmountFactory()
                        .setCurrency("USD").setNumber(200.50).create();
                        
 Still we can evaluate the effective amount’s type effectively:
@@ -167,7 +166,7 @@ effectively used (by default ``Money`` uses ``MathContext.DECIMAL64``).:
 
 #### 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_EVEN)).build()
     );
@@ -222,7 +221,7 @@ the possible amounts to be modeled are limited to an overall precision of 18 and
 Beside that the overall handling of ``FastMoney`` is similar to ``Money``. So we could rewrite the former
 example by just replacing ``FastMoney`` with ``Money``:
 
-    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();
@@ -269,7 +268,7 @@ As an alternate it is also possible to define a ``MonetaryOperator``, which can
       }
 
       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/asciidoc/JavaMoneySpecification.adoc

@@ -0,0 +1,85 @@
+/*
+ * 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.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Factory singleton for {@link 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<>();
+        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<>();
+        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<>();
+        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;
+    }
+
+}

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

@@ -0,0 +1,178 @@
+/*
+ * 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.MonetaryRoundingsSingletonSpi;
+import javax.money.spi.RoundingProviderSpi;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * This class models the accessor for rounding instances, modeled as
+ * {@link javax.money.MonetaryOperator}.
+ * <p/>
+ * This class is thread-safe.
+ *
+ * @author Anatole Tresch
+ * @author Werner Keil
+ */
+final class DefaultMonetaryRoundingsSingletonSpi implements MonetaryRoundingsSingletonSpi {
+
+    /**
+     * An adaptive rounding instance that transparently looks up the correct
+     * rounding.
+     */
+    private static final MonetaryRounding DEFAULT_ROUNDING = new DefaultCurrencyRounding();
+
+    /**
+     * Creates an rounding instance using {@link java.math.RoundingMode#UP} rounding.
+     *
+     * @return the corresponding {@link MonetaryOperator} implementing the
+     * rounding.
+     * @throws MonetaryException if no such rounding could be evaluated.
+     */
+    public RoundingQueryBuilder createRoundingQueryBuilder() {
+        throw new IllegalStateException("No MonetaryRoundingsSingletonSpi registered.");
+    }
+
+    /**
+     * Get the default rounding, which delegates rounding dynamically depending on the current  currency.
+     *
+     * @return the default rounding, never null.
+     */
+    public MonetaryRounding getDefaultRounding() {
+        return DEFAULT_ROUNDING;
+    }
+
+
+    /**
+     * Query all roundings matching the given {@link RoundingQuery}.
+     *
+     * @param query the rounding query, not null.
+     * @return the collection found, not null.
+     */
+    @Override
+    public Collection<MonetaryRounding> getRoundings(RoundingQuery query) {
+        List<MonetaryRounding> result = new ArrayList<>();
+        Collection<String> providerNames = query.getProviderNames();
+        if (providerNames == null || providerNames.isEmpty()) {
+            providerNames = getDefaultProviderChain();
+        }
+        for (String providerName : providerNames) {
+            Bootstrap.getServices(RoundingProviderSpi.class).stream()
+                    .filter(prov -> providerName.equals(prov.getProviderName())).forEach(prov -> {
+                try {
+                    MonetaryRounding r = prov.getRounding(query);
+                    if (r != null) {
+                        result.add(r);
+                    }
+                } catch (Exception e) {
+                    Logger.getLogger(DefaultMonetaryRoundingsSingletonSpi.class.getName())
+                            .log(Level.SEVERE, "Error loading RoundingProviderSpi from provider: " + prov, e);
+                }
+            });
+        }
+        return result;
+    }
+
+    /**
+     * Get the names of all current registered providers.
+     *
+     * @return the names of all current registered providers, never null.
+     */
+    @Override
+    public Set<String> getProviderNames() {
+        Set<String> result = new HashSet<>();
+        for (RoundingProviderSpi prov : Bootstrap.getServices(RoundingProviderSpi.class)) {
+            try {
+                result.add(prov.getProviderName());
+            } catch (Exception e) {
+                Logger.getLogger(Monetary.class.getName())
+                        .log(Level.SEVERE, "Error loading RoundingProviderSpi from provider: " + prov, e);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Get the default providers list to be used.
+     *
+     * @return the default provider list and ordering, not null.
+     */
+    @Override
+    public List<String> getDefaultProviderChain() {
+        List<String> result = new ArrayList<>();
+        result.addAll(Monetary.getRoundingProviderNames());
+        Collections.sort(result);
+        return result;
+    }
+
+    /**
+     * Allows to access the identifiers of the current defined roundings.
+     *
+     * @param providers the providers and ordering to be used. By default providers and ordering as defined in
+     *                  #getDefaultProviders is used, not null.
+     * @return the set of custom rounding ids, never {@code null}.
+     */
+    public Set<String> getRoundingNames(String... providers) {
+        Set<String> result = new HashSet<>();
+        String[] providerNames = providers;
+        if (providerNames.length == 0) {
+            providerNames = Monetary.getDefaultRoundingProviderChain().toArray(new String[Monetary.getDefaultRoundingProviderChain().size()]);
+        }
+        for (String providerName : providerNames) {
+            for (RoundingProviderSpi prov : Bootstrap.getServices(RoundingProviderSpi.class)) {
+                try {
+                    if (prov.getProviderName().equals(providerName) || prov.getProviderName().matches(providerName)) {
+                        result.addAll(prov.getRoundingNames());
+                    }
+                } catch (Exception e) {
+                    Logger.getLogger(DefaultMonetaryRoundingsSingletonSpi.class.getName())
+                            .log(Level.SEVERE, "Error loading RoundingProviderSpi from provider: " + prov, e);
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Default Rounding that rounds a {@link MonetaryAmount} based on the
+     * amount's {@link CurrencyUnit}.
+     *
+     * @author Anatole Tresch
+     */
+    private static final class DefaultCurrencyRounding implements MonetaryRounding, Serializable {
+
+        private static final RoundingContext ROUNDING_CONTEXT = RoundingContextBuilder.of("default", "default").build();
+
+        @Override
+        public MonetaryAmount apply(MonetaryAmount amount) {
+            MonetaryRounding r = Monetary.getRounding(amount.getCurrency());
+            return r.apply(amount);
+        }
+
+        @Override
+        public RoundingContext getRoundingContext() {
+            return ROUNDING_CONTEXT;
+        }
+    }
+
+}