JAVAMONEY-97: Merged singletons into Money in core package.

Author: atsticks

pom.xml

@@ -146,8 +146,8 @@
     </developers>
 
     <ciManagement>
-        <system>Jenkins</system>
-        <url>https://jsr354.ci.cloudbees.com/</url>
+        <system>Travis CI</system>
+        <url>https://travis-ci.org/JavaMoney/jsr354-ri</url>
     </ciManagement>
 
     <mailingLists>

src/main/asciidoc/userguide.adoc

@@ -75,9 +75,9 @@ You can use the currency code to access currencies.
 [source,java]
 .Accessing currencies by currency code
 --------------------------------------------
-CurrencyUnit currencyCHF = MonetaryCurrencies.getCurrencyUnit("CHF");
-CurrencyUnit currencyUSD = MonetaryCurrencies.getCurrencyUnit("USD");
-CurrencyUnit currencyEUR = MonetaryCurrencies.getCurrencyUnit("EUR");
+CurrencyUnit currencyCHF = Monetary.getCurrencyUnit("CHF");
+CurrencyUnit currencyUSD = Monetary.getCurrencyUnit("USD");
+CurrencyUnit currencyEUR = Monetary.getCurrencyUnit("EUR");
 --------------------------------------------
 
 Hereby all codes available in the underlying JDK are mapped by default.
@@ -98,9 +98,9 @@ Similarly to +java.util.Currency+ a +CurrencyUnit+ can be accessed using this +L
 [source,java]
 .Accessing currencies by Locale
 --------------------------------------------
-CurrencyUnit currencyCHF = MonetaryCurrencies.getCurrencyUnit(new Locale("", "SUI")); // Switzerland
-CurrencyUnit currencyUSD = MonetaryCurrencies.getCurrencyUnit(new Locale("", "USA")); // United States of America
-CurrencyUnit currencyEUR = MonetaryCurrencies.getCurrencyUnit(new Locale("", "GER")); // Germany
+CurrencyUnit currencyCHF = Monetary.getCurrencyUnit(new Locale("", "SUI")); // Switzerland
+CurrencyUnit currencyUSD = Monetary.getCurrencyUnit(new Locale("", "USA")); // United States of America
+CurrencyUnit currencyEUR = Monetary.getCurrencyUnit(new Locale("", "GER")); // Germany
 --------------------------------------------
 
 Hereby all codes available in the underlying JDK are mapped by default.
@@ -112,7 +112,7 @@ Also all currently known currencies can be accessed:
 [source,java]
 .Accessing all currencies
 --------------------------------------------
-Collection<CurrencyUnit> allCurrencies = MonetaryCurrencies.getCurrencies();
+Collection<CurrencyUnit> allCurrencies = Monetary.getCurrencies();
 --------------------------------------------
 
 Similarly to other access methods you can also explicitly specifiy the provider chain to be used. The _Moneta_
@@ -235,8 +235,8 @@ sublist, when the according code is requested, or a unspecified request is perfo
 CurrencyUnit unit = CurrencyUnitBuilder.of("FLS22").setDefaultFractionUnits(3).build();
 
 // registering it
-MonetaryCurrencies.registerCurrency(unit);
-MonetaryCurrencies.registerCurrency(unit, Locale.MyCOUNTRY);
+Monetary.registerCurrency(unit);
+Monetary.registerCurrency(unit, Locale.MyCOUNTRY);
 --------------------------------------------
 
 Fortunately +CurrencyUnitBuilder+ is also capable of registering a currency on creation, by just passing
@@ -256,8 +256,8 @@ Alternatively one may use the +MonetaryCurrencies+ static methods as follows:
 CurrencyUnit unit = new CurrencyUnitBuilder.of("FLS22").setDefaultFractionUnits(3).build();
 
 // registering it
-MonetaryCurrencies.registerCurrency(unit);
-MonetaryCurrencies.registerCurrency(unit, Locale.MyCOUNTRY);
+Monetary.registerCurrency(unit);
+Monetary.registerCurrency(unit, Locale.MyCOUNTRY);
 --------------------------------------------
 
 ==== Provided Currencies
@@ -291,7 +291,7 @@ new instances of amounts. E.g. instances of +FastMoney+ can be created as follow
 [source,java]
 .Creating instances of +FastMoney+ using the +MonetaryAmounts+ singleton:
 --------------------------------------------
-FastMoney m = MonetaryAmounts.getAmountFactory(FastMoney.class).setCurrency("USD").setNumber(200.20).create();
+FastMoney m = Monetary.getAmountFactory(FastMoney.class).setCurrency("USD").setNumber(200.20).create();
 --------------------------------------------
 
 Additionally _Moneta_ also supports static factory methods on the types directly. So the following code is equivalent:
@@ -307,7 +307,7 @@ Creation of +Money+ instances is similar:
 [source,java]
 .Creating instances of +Money+:
 --------------------------------------------
-Money m1 = MonetaryAmounts.getAmountFactory(Money.class).setCurrency("USD").setNumber(200.20).create();
+Money m1 = Monetary.getAmountFactory(Money.class).setCurrency("USD").setNumber(200.20).create();
 Money m2 = Money.of("USD", 200.20);
 --------------------------------------------
 
@@ -329,7 +329,7 @@ Using the JSR's main API allows to achieve the same as follows:
 [source,java]
 .Creating instances of +Money+ configuring the +MathContext+ to be used, using the +MonetaryAmountFactory+.
 --------------------------------------------
-Money money = MonetaryAmounts.getAmountFactory(Money.class)
+Money money = Monetary.getAmountFactory(Money.class)
                               .setCurrencyUnit("CHF").setNumber(200).
                               ,setContext(MonetaryContextBuilder.create().set(MathContext.DECIMAL128).build())
                               .create();
@@ -488,7 +488,7 @@ M money1 = money1.add(M.of(EURO, 1234567.3444));
 money1 = money1.subtract(M.of(EURO, 232323));
 money1 = money1.multiply(3.4);
 money1 = money1.divide(5.456);
-money1 = money1.with(MonetaryRoundings.getRounding());
+money1 = money1.with(Monetary.getRounding());
 --------------------------------------------
 
 All tests were executed on a notebook with an +Intel i7 2.6GHz+ processor with SSD.
@@ -526,7 +526,7 @@ the +RoundingQuery+ passed:
 [source,java]
 .Access and apply arithmetic rounding.
 --------------------------------------------
-MonetaryRounding rounding = MonetaryRoundings.getRounding(
+MonetaryRounding rounding = Monetary.getRounding(
                                RoundingQueryBuilder.create().setScale(4).set(RoundingMode.HALF_UP).build());
 MonetaryAmount amt = ...;
 MonetaryAmount roundedAmount = amt.with(rounding);
@@ -540,9 +540,9 @@ based on the current amount instance to be rounded:
 [source,java]
 .Access and apply default rounding.
 --------------------------------------------
-MonetaryRounding rounding = MonetaryRoundings.getDefaultRounding();
+MonetaryRounding rounding = Monetary.getDefaultRounding();
 MonetaryAmount amt = ...;
-MonetaryAmount roundedAmount = amt.with(rounding); // implicitly uses MonetaryRoundings.getRounding(CurrencyUnit);
+MonetaryAmount roundedAmount = amt.with(rounding); // implicitly uses Monetary.getRounding(CurrencyUnit);
 --------------------------------------------
 
 Also you can access the default rounding for a given +CurrencyUnit+. Be default this will return an arithmetic rounding
@@ -552,9 +552,9 @@ based on the currency's _default fraction digits_, but it may also return a non
 .Access and apply default currency rounding.
 --------------------------------------------
 CurrencyUnit currency = ...;
-MonetaryRounding rounding = MonetaryRoundings.getRounding(currency);
+MonetaryRounding rounding = Monetary.getRounding(currency);
 MonetaryAmount amt = ...;
-MonetaryAmount roundedAmount = amt.with(rounding); // implicitly uses MonetaryRoundings.getRounding(CurrencyUnit);
+MonetaryAmount roundedAmount = amt.with(rounding); // implicitly uses Monetary.getRounding(CurrencyUnit);
 --------------------------------------------
 
 For Swiss Francs also a corresponding cash rounding is accessible. In Switzerland the smallest minor in cash are
@@ -564,7 +564,7 @@ For Swiss Francs also a corresponding cash rounding is accessible. In Switzerlan
 [source,java]
 .Access Swiss Francs Cash Rounding
 --------------------------------------------
-MonetaryRounding rounding = MonetaryRoundings.getRounding(MonetaryCurrencies.getCurrency("CHF"),
+MonetaryRounding rounding = Monetary.getRounding(Monetary.getCurrency("CHF"),
   RoundingQueryBuilder.create().set("cashRounding", true).build()
 );
 MonetaryAmount amt = ...;

src/main/java/org/javamoney/moneta/BuildableCurrencyUnit.java

@@ -23,7 +23,7 @@
 /**
  * Implementation of {@link javax.money.CurrencyUnit} that allows to of new instances using a fluent API.
  * Instances created also can be added to the {@link org.javamoney.moneta.internal.ConfigurableCurrencyUnitProvider}
- * singleton, which publishes the instances, so they are visible from the {@link javax.money.MonetaryCurrencies}
+ * singleton, which publishes the instances, so they are visible from the {@link javax.money.Monetary}
  * singleton.
  */
 final class BuildableCurrencyUnit implements CurrencyUnit, Comparable<CurrencyUnit>, Serializable {

src/main/java/org/javamoney/moneta/CurrencyUnitBuilder.java

@@ -143,7 +143,7 @@ public CurrencyUnit build() {
      * @param register if {@code true} the instance created is published so it is accessible from
      *                 the {@code MonetaryCurrencies} singleton.
      * @return the new CurrencyUnit instance.
-     * @see javax.money.MonetaryCurrencies#getCurrency(String, String...)
+     * @see javax.money.Monetary#getCurrency(String, String...)
      */
     public CurrencyUnit build(boolean register) {
         BuildableCurrencyUnit cu = new BuildableCurrencyUnit(this);
@@ -161,8 +161,8 @@ public CurrencyUnit build(boolean register) {
      *                 the {@code MonetaryCurrencies} singleton.
      * @param locale   country Locale for making the currency for the given country.
      * @return the new CurrencyUnit instance.
-     * @see javax.money.MonetaryCurrencies#getCurrency(String, String...)
-     * @see javax.money.MonetaryCurrencies#getCurrency(java.util.Locale, String...)
+     * @see javax.money.Monetary#getCurrency(String, String...)
+     * @see javax.money.Monetary#getCurrency(java.util.Locale, String...)
      */
     public CurrencyUnit build(boolean register, Locale locale) {
         BuildableCurrencyUnit cu = new BuildableCurrencyUnit(this);

src/main/java/org/javamoney/moneta/FastMoney.java

@@ -113,15 +113,15 @@ public final class FastMoney implements MonetaryAmount, Comparable<MonetaryAmoun
     /**
      * Maximum possible value supported, using XX (no currency).
      */
-    public static final FastMoney MAX_VALUE = new FastMoney(Long.MAX_VALUE, MonetaryCurrencies.getCurrency("XXX"));
+    public static final FastMoney MAX_VALUE = new FastMoney(Long.MAX_VALUE, Monetary.getCurrency("XXX"));
     /**
      * Maximum possible numeric value supported.
      */
     private static final BigDecimal MAX_BD = MAX_VALUE.getBigDecimal();
     /**
      * Minimum possible value supported, using XX (no currency).
      */
-    public static final FastMoney MIN_VALUE = new FastMoney(Long.MIN_VALUE, MonetaryCurrencies.getCurrency("XXX"));
+    public static final FastMoney MIN_VALUE = new FastMoney(Long.MIN_VALUE, Monetary.getCurrency("XXX"));
     /**
      * Minimum possible numeric value supported.
      */
@@ -234,7 +234,7 @@ public static FastMoney of(Number number, CurrencyUnit currency) {
      * @return A new instance of {@link FastMoney}.
      */
     public static FastMoney of(Number number, String currencyCode) {
-        CurrencyUnit currency = MonetaryCurrencies.getCurrency(currencyCode);
+        CurrencyUnit currency = Monetary.getCurrency(currencyCode);
         return of(number, currency);
     }
 

src/main/java/org/javamoney/moneta/Money.java

@@ -25,7 +25,7 @@
 import javax.money.MonetaryAmount;
 import javax.money.MonetaryAmountFactory;
 import javax.money.MonetaryContext;
-import javax.money.MonetaryCurrencies;
+import javax.money.Monetary;
 import javax.money.MonetaryException;
 import javax.money.MonetaryOperator;
 import javax.money.MonetaryQuery;
@@ -753,7 +753,7 @@ public static Money of(Number number, CurrencyUnit currency, MonetaryContext mon
      * @return A new instance of {@link Money}.
      */
     public static Money of(Number number, String currencyCode) {
-        return new Money(MoneyUtils.getBigDecimal(number), MonetaryCurrencies.getCurrency(currencyCode));
+        return new Money(MoneyUtils.getBigDecimal(number), Monetary.getCurrency(currencyCode));
     }
 
     /**
@@ -764,7 +764,7 @@ public static Money of(Number number, String currencyCode) {
      * @return A new instance of {@link Money}.
      */
     public static Money of(BigDecimal number, String currencyCode) {
-        return new Money(number, MonetaryCurrencies.getCurrency(currencyCode));
+        return new Money(number, Monetary.getCurrency(currencyCode));
     }
 
     /**
@@ -777,7 +777,7 @@ public static Money of(BigDecimal number, String currencyCode) {
      * @return A new instance of {@link Money}.
      */
     public static Money of(Number number, String currencyCode, MonetaryContext monetaryContext) {
-        return new Money(MoneyUtils.getBigDecimal(number), MonetaryCurrencies.getCurrency(currencyCode),
+        return new Money(MoneyUtils.getBigDecimal(number), Monetary.getCurrency(currencyCode),
                 monetaryContext);
     }
 
@@ -791,7 +791,7 @@ public static Money of(Number number, String currencyCode, MonetaryContext monet
      * @return A new instance of {@link Money}.
      */
     public static Money of(BigDecimal number, String currencyCode, MonetaryContext monetaryContext) {
-        return new Money(number, MonetaryCurrencies.getCurrency(currencyCode), monetaryContext);
+        return new Money(number, Monetary.getCurrency(currencyCode), monetaryContext);
     }
 
     /**

src/main/java/org/javamoney/moneta/RoundedMoney.java

@@ -52,7 +52,7 @@ public final class RoundedMoney implements MonetaryAmount, Comparable<MonetaryAm
      * The default {@link MonetaryContext} applied.
      */
     public static final MonetaryContext DEFAULT_MONETARY_CONTEXT = MonetaryContextBuilder.of(RoundedMoney.class)
-            .set("MonetaryRounding", MonetaryRoundings.getDefaultRounding()).
+            .set("MonetaryRounding", Monetary.getDefaultRounding()).
                     build();
 
     /**
@@ -89,7 +89,7 @@ public RoundedMoney(Number number, CurrencyUnit currency, MonetaryOperator round
     public RoundedMoney(Number number, CurrencyUnit currency, MathContext mathContext) {
         Objects.requireNonNull(currency, "Currency is required.");
         this.currency = currency;
-        this.rounding = MonetaryRoundings.getRounding(RoundingQueryBuilder.of().set(mathContext).build());
+        this.rounding = Monetary.getRounding(RoundingQueryBuilder.of().set(mathContext).build());
         this.monetaryContext =
                 DEFAULT_MONETARY_CONTEXT.toBuilder().set("MonetaryRounding", rounding).set(mathContext)
                         .build();
@@ -116,17 +116,17 @@ public RoundedMoney(Number number, CurrencyUnit currency, MonetaryContext contex
                         Integer scale = Optional.ofNullable(context.getInt("scale")).orElse(2);
                         b.set(rm);
                         b.set("scale", scale);
-                        this.rounding = MonetaryRoundings
+                        this.rounding = Monetary
                                 .getRounding(RoundingQueryBuilder.of().setScale(scale).set(rm).build());
                     }
                 } else {
                     b.set(mc.getRoundingMode());
                     b.set("scale", 2);
                     this.rounding =
-                            MonetaryRoundings.getRounding(RoundingQueryBuilder.of().set(mc).setScale(2).build());
+                            Monetary.getRounding(RoundingQueryBuilder.of().set(mc).setScale(2).build());
                 }
                 if (this.rounding == null) {
-                    this.rounding = MonetaryRoundings.getDefaultRounding();
+                    this.rounding = Monetary.getDefaultRounding();
                 }
             }
         }
@@ -149,7 +149,7 @@ public RoundedMoney(Number number, CurrencyUnit currency, MonetaryContext contex
      * @return a {@code Money} combining the numeric value and currency unit.
      */
     public static RoundedMoney of(BigDecimal number, CurrencyUnit currency) {
-        return new RoundedMoney(number, currency, MonetaryRoundings.getDefaultRounding());
+        return new RoundedMoney(number, currency, Monetary.getDefaultRounding());
     }
 
     /**
@@ -236,8 +236,8 @@ public static RoundedMoney of(CurrencyUnit currency, Number number, MonetaryCont
      * @return A new instance of {@link RoundedMoney}.
      */
     public static RoundedMoney of(Number number, String currencyCode) {
-        return new RoundedMoney(number, MonetaryCurrencies.getCurrency(currencyCode),
-                MonetaryRoundings.getDefaultRounding());
+        return new RoundedMoney(number, Monetary.getCurrency(currencyCode),
+                Monetary.getDefaultRounding());
     }
 
     /**
@@ -249,7 +249,7 @@ public static RoundedMoney of(Number number, String currencyCode) {
      * @return A new instance of {@link RoundedMoney}.
      */
     public static RoundedMoney of(Number number, String currencyCode, MonetaryOperator rounding) {
-        return new RoundedMoney(number, MonetaryCurrencies.getCurrency(currencyCode), rounding);
+        return new RoundedMoney(number, Monetary.getCurrency(currencyCode), rounding);
     }
 
     /**
@@ -260,7 +260,7 @@ public static RoundedMoney of(Number number, String currencyCode, MonetaryOperat
      * @return A new instance of {@link RoundedMoney}.
      */
     public static RoundedMoney of(Number number, String currencyCode, MonetaryContext monetaryContext) {
-        return new RoundedMoney(number, MonetaryCurrencies.getCurrency(currencyCode),
+        return new RoundedMoney(number, Monetary.getCurrency(currencyCode),
                 DEFAULT_MONETARY_CONTEXT.toBuilder().importContext(monetaryContext).build(), null);
     }
 
@@ -274,7 +274,7 @@ public static RoundedMoney of(Number number, String currencyCode, MonetaryContex
      */
     public static RoundedMoney of(String currencyCode, Number number, MonetaryContext monetaryContext,
                                   MonetaryOperator rounding) {
-        return new RoundedMoney(number, MonetaryCurrencies.getCurrency(currencyCode),
+        return new RoundedMoney(number, Monetary.getCurrency(currencyCode),
                 DEFAULT_MONETARY_CONTEXT.toBuilder().importContext(monetaryContext).build(), rounding);
     }
 

src/main/java/org/javamoney/moneta/ToStringMonetaryAmountFormat.java

@@ -7,7 +7,7 @@
 
 import javax.money.CurrencyUnit;
 import javax.money.MonetaryAmount;
-import javax.money.MonetaryCurrencies;
+import javax.money.Monetary;
 import javax.money.format.AmountFormatContext;
 import javax.money.format.MonetaryAmountFormat;
 import javax.money.format.MonetaryParseException;
@@ -61,7 +61,7 @@ public MonetaryAmount parse(CharSequence text)
 
     private ParserMonetaryAmount parserMonetaryAmount(CharSequence text) {
         String[] array = Objects.requireNonNull(text).toString().split(" ");
-        CurrencyUnit currencyUnit = MonetaryCurrencies.getCurrency(array[0]);
+        CurrencyUnit currencyUnit = Monetary.getCurrency(array[0]);
         BigDecimal number = new BigDecimal(array[1]);
         return new ParserMonetaryAmount(currencyUnit, number);
     }

src/main/java/org/javamoney/moneta/function/MajorPart.java

@@ -27,7 +27,7 @@
 final class MajorPart implements MonetaryOperator {
 
     private static final MonetaryRounding downRounding =
-            MonetaryRoundings.getRounding(RoundingQueryBuilder.of().setScale(0).set(RoundingMode.DOWN).build());
+            Monetary.getRounding(RoundingQueryBuilder.of().setScale(0).set(RoundingMode.DOWN).build());
 
     /**
      * Access the shared instance of {@link MajorPart} for use.

src/main/java/org/javamoney/moneta/function/MajorUnits.java

@@ -29,7 +29,7 @@
 final class MajorUnits implements MonetaryQuery<Long> {
 
     private MonetaryOperator downRounding =
-            MonetaryRoundings.getRounding(RoundingQueryBuilder.of().setScale(0).set(RoundingMode.DOWN).build());
+            Monetary.getRounding(RoundingQueryBuilder.of().setScale(0).set(RoundingMode.DOWN).build());
 
     /**
      * Access the shared instance of {@link MajorUnits} for use.