Quality fixes, added Javadocs.

Author: atsticks

README.md

@@ -1,7 +1,8 @@
-JSR 354: Money and Currency Reference Implementation
-====================================================
+JSR 354: Money and Currency Moneta Reference Implementation
+===========================================================
 JSR 354 provides an API for representing, transporting, and performing comprehensive calculations with Money and Currency. 
-This module implements JSR 354 Money & Currency. Hereby basic implementations of amounts, currency and roundings are provided.
+This module (moneta) implements JSR 354 Money & Currency. Hereby basic implementations of amounts, currency and roundings 
+are provided.
 
 See the JCP detail page:
 http://jcp.org/en/jsr/detail?id=354

pom.xml

@@ -24,7 +24,7 @@
 
     <artifactId>moneta</artifactId>
     <version>1.0</version>
-    <packaging>jar</packaging>
+    <packaging>bundle</packaging>
 
     <name>Moneta (JSR 354 RI)</name>
     <url>http://javamoney.org</url>

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

@@ -111,7 +111,7 @@ class DefaultExchangeRate implements ExchangeRate, Serializable, Comparable<Exch
     /**
      * The full chain, at least one instance long.
      */
-    private List<ExchangeRate> chain = new ArrayList<>();
+    private final List<ExchangeRate> chain = new ArrayList<>();
 
 
     /**
@@ -266,7 +266,7 @@ public boolean equals(Object obj) {
         }
         if (obj instanceof DefaultExchangeRate) {
             DefaultExchangeRate other = (DefaultExchangeRate) obj;
-            return Objects.equals(base, other.base) && Objects.equals(chain, other.chain) &&
+            return Objects.equals(base, other.base) &&
                     Objects.equals(conversionContext, other.conversionContext) &&
                     Objects.equals(factor, other.factor) && Objects.equals(term, other.term);
         }

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

@@ -47,9 +47,9 @@ public enum ExchangeRateType implements ExchangeRateProviderSupplier {
             "IDENT",
             "Exchange rate rate with factor one for identical base/term currencies");
 
-    private String type;
+    private final String type;
 
-    private String description;
+    private final String description;
 
     ExchangeRateType(String type, String description) {
         this.type = type;
@@ -61,7 +61,6 @@ public String get() {
         return type;
     }
 
-    @Override
     public String getDescription() {
         return description;
     }

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

@@ -443,8 +443,8 @@ private boolean isOne(Number number) {
      * @see javax.money.MonetaryAmount#scaleByPowerOfTen(int)
      */
     @Override
-    public FastMoney scaleByPowerOfTen(int n) {
-        return new FastMoney(getNumber().numberValue(BigDecimal.class).scaleByPowerOfTen(n), getCurrency(), true);
+    public FastMoney scaleByPowerOfTen(int power) {
+        return new FastMoney(getNumber().numberValue(BigDecimal.class).scaleByPowerOfTen(power), getCurrency(), true);
     }
 
     /*
@@ -648,7 +648,7 @@ public String toString() {
      * @throws NullPointerException          If the number is null
      * @throws java.lang.ArithmeticException If the number exceeds the capabilities of this class.
      */
-    protected void checkNumber(Number number) {
+    private void checkNumber(Number number) {
         Objects.requireNonNull(number, "Number is required.");
         // numeric check for overflow...
         if (number.longValue() > MAX_BD.longValue()) {
@@ -731,71 +731,71 @@ public static FastMoney parse(CharSequence text, MonetaryAmountFormat formatter)
         return from(formatter.parse(text));
     }
 
-    private static ToStringMonetaryAmountFormat DEFAULT_FORMATTER = ToStringMonetaryAmountFormat
+    private static final ToStringMonetaryAmountFormat DEFAULT_FORMATTER = ToStringMonetaryAmountFormat
             .of(ToStringMonetaryAmountFormatStyle.FAST_MONEY);
 
     private BigDecimal getBigDecimal() {
         return BigDecimal.valueOf(this.number).movePointLeft(SCALE);
     }
 
     @Override
-    public FastMoney multiply(double amount) {
-        Money.checkNoInfinityOrNaN(amount);
-        if (amount == 1.0) {
+    public FastMoney multiply(double multiplicand) {
+        Money.checkNoInfinityOrNaN(multiplicand);
+        if (multiplicand == 1.0) {
             return this;
         }
-        if (amount == 0.0) {
+        if (multiplicand == 0.0) {
             return new FastMoney(0, this.currency);
         }
-        return new FastMoney(Math.round(this.number * amount), this.currency);
+        return new FastMoney(Math.round(this.number * multiplicand), this.currency);
     }
 
     @Override
-    public FastMoney divide(long amount) {
-        if (amount == 1L) {
+    public FastMoney divide(long divisor) {
+        if (divisor == 1L) {
             return this;
         }
-        return new FastMoney(this.number / amount, this.currency);
+        return new FastMoney(this.number / divisor, this.currency);
     }
 
     @Override
-    public FastMoney divide(double number) {
-        if (Money.isInfinityAndNotNaN(number)) {
+    public FastMoney divide(double divisor) {
+        if (Money.isInfinityAndNotNaN(divisor)) {
             return new FastMoney(0L, getCurrency());
         }
-        if (number == 1.0d) {
+        if (divisor == 1.0d) {
             return this;
         }
-        return new FastMoney(Math.round(this.number / number), getCurrency());
+        return new FastMoney(Math.round(this.number / divisor), getCurrency());
     }
 
     @Override
-    public FastMoney remainder(long number) {
-        return remainder(BigDecimal.valueOf(number));
+    public FastMoney remainder(long divisor) {
+        return remainder(BigDecimal.valueOf(divisor));
     }
 
     @Override
-    public FastMoney remainder(double amount) {
-        if (Money.isInfinityAndNotNaN(amount)) {
+    public FastMoney remainder(double divisor) {
+        if (Money.isInfinityAndNotNaN(divisor)) {
             return new FastMoney(0L, getCurrency());
         }
-        return remainder(new BigDecimal(String.valueOf(amount)));
+        return remainder(new BigDecimal(String.valueOf(divisor)));
     }
 
     @Override
-    public FastMoney[] divideAndRemainder(long amount) {
-        return divideAndRemainder(BigDecimal.valueOf(amount));
+    public FastMoney[] divideAndRemainder(long divisor) {
+        return divideAndRemainder(BigDecimal.valueOf(divisor));
     }
 
     @Override
-    public FastMoney[] divideAndRemainder(double amount) {
-        if (Money.isInfinityAndNotNaN(amount)) {
+    public FastMoney[] divideAndRemainder(double divisor) {
+        if (Money.isInfinityAndNotNaN(divisor)) {
             FastMoney zero = new FastMoney(0L, getCurrency());
             return new FastMoney[]{zero, zero};
-        } else if (amount == Double.NaN) {
+        } else if (divisor == Double.NaN) {
             throw new ArithmeticException("Not a number: NaN.");
         }
-        return divideAndRemainder(new BigDecimal(String.valueOf(amount)));
+        return divideAndRemainder(new BigDecimal(String.valueOf(divisor)));
     }
 
     @Override

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

@@ -91,7 +91,7 @@ public final class Money implements MonetaryAmount, Comparable<MonetaryAmount>,
     /**
      * The numeric part of this amount.
      */
-    private BigDecimal number;
+    private final BigDecimal number;
 
     /**
      * Creates a new instance os {@link Money}.
@@ -517,12 +517,12 @@ public Money plus() {
      * @see javax.money.MonetaryAmount#subtract(javax.money.MonetaryAmount)
      */
     @Override
-    public Money subtract(MonetaryAmount subtrahend) {
-        MoneyUtils.checkAmountParameter(subtrahend, this.currency);
-        if (subtrahend.isZero()) {
+    public Money subtract(MonetaryAmount amount) {
+        MoneyUtils.checkAmountParameter(amount, this.currency);
+        if (amount.isZero()) {
             return this;
         }
-        return new Money(this.number.subtract(subtrahend.getNumber().numberValue(BigDecimal.class)), getCurrency());
+        return new Money(this.number.subtract(amount.getNumber().numberValue(BigDecimal.class)), getCurrency());
     }
 
     /*
@@ -558,8 +558,8 @@ public Money remainder(Number divisor) {
      * @see javax.money.MonetaryAmount#scaleByPowerOfTen(int)
      */
     @Override
-    public Money scaleByPowerOfTen(int n) {
-        return new Money(this.number.scaleByPowerOfTen(n), getCurrency());
+    public Money scaleByPowerOfTen(int power) {
+        return new Money(this.number.scaleByPowerOfTen(power), getCurrency());
     }
 
     /*
@@ -834,7 +834,7 @@ public static Money parse(CharSequence text, MonetaryAmountFormat formatter) {
         return from(formatter.parse(text));
     }
 
-    private static ToStringMonetaryAmountFormat DEFAULT_FORMATTER = ToStringMonetaryAmountFormat
+    private static final ToStringMonetaryAmountFormat DEFAULT_FORMATTER = ToStringMonetaryAmountFormat
             .of(ToStringMonetaryAmountFormatStyle.MONEY);
 
     public static void checkNoInfinityOrNaN(Number number) {

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

@@ -73,7 +73,7 @@ public final class RoundedMoney implements MonetaryAmount, Comparable<MonetaryAm
     /**
      * The rounding to be done.
      */
-    private MonetaryOperator rounding;
+    private final MonetaryOperator rounding;
 
 
     /**
@@ -119,15 +119,18 @@ public RoundedMoney(Number number, CurrencyUnit currency, MonetaryContext contex
                         this.rounding = Monetary
                                 .getRounding(RoundingQueryBuilder.of().setScale(scale).set(rm).build());
                     }
+                    else{
+                        this.rounding = Monetary.getDefaultRounding();
+                    }
                 } else {
                     b.set(mc.getRoundingMode());
                     b.set("scale", 2);
                     this.rounding =
                             Monetary.getRounding(RoundingQueryBuilder.of().set(mc).setScale(2).build());
                 }
-                if (this.rounding == null) {
-                    this.rounding = Monetary.getDefaultRounding();
-                }
+            }
+            else{
+                this.rounding = Monetary.getDefaultRounding();
             }
         }
         b.set("MonetaryRounding", this.rounding);
@@ -401,12 +404,12 @@ public RoundedMoney plus() {
      * @see javax.money.MonetaryAmount#subtract(javax.money.MonetaryAmount)
      */
     @Override
-    public RoundedMoney subtract(MonetaryAmount subtrahend) {
-        MoneyUtils.checkAmountParameter(subtrahend, this.currency);
-        if (subtrahend.isZero()) {
+    public RoundedMoney subtract(MonetaryAmount amount) {
+        MoneyUtils.checkAmountParameter(amount, this.currency);
+        if (amount.isZero()) {
             return this;
         }
-        return new RoundedMoney(this.number.subtract(subtrahend.getNumber().numberValue(BigDecimal.class),
+        return new RoundedMoney(this.number.subtract(amount.getNumber().numberValue(BigDecimal.class),
                 Optional.ofNullable(
                         this.monetaryContext.get(MathContext.class)).orElse(MathContext.DECIMAL64)),
                 this.currency, this.rounding);
@@ -446,8 +449,8 @@ public RoundedMoney remainder(Number divisor) {
      * @see javax.money.MonetaryAmount#scaleByPowerOfTen(int)
      */
     @Override
-    public RoundedMoney scaleByPowerOfTen(int n) {
-        return new RoundedMoney(this.number.scaleByPowerOfTen(n), this.currency, this.rounding);
+    public RoundedMoney scaleByPowerOfTen(int power) {
+        return new RoundedMoney(this.number.scaleByPowerOfTen(power), this.currency, this.rounding);
     }
 
     /*
@@ -669,7 +672,7 @@ public static RoundedMoney parse(CharSequence text, MonetaryAmountFormat formatt
         return from(formatter.parse(text));
     }
 
-    private static ToStringMonetaryAmountFormat DEFAULT_FORMATTER = ToStringMonetaryAmountFormat
+    private static final ToStringMonetaryAmountFormat DEFAULT_FORMATTER = ToStringMonetaryAmountFormat
             .of(ToStringMonetaryAmountFormatStyle.ROUNDED_MONEY);
 
     /*
@@ -815,66 +818,66 @@ private void checkNumber(Number number) {
     }
 
     @Override
-    public RoundedMoney multiply(long amount) {
-        if (amount == 1L) {
+    public RoundedMoney multiply(long multiplicand) {
+        if (multiplicand == 1L) {
             return this;
         }
-        return multiply(MoneyUtils.getBigDecimal(amount));
+        return multiply(MoneyUtils.getBigDecimal(multiplicand));
     }
 
     @Override
-    public RoundedMoney multiply(double amount) {
-        Money.checkNoInfinityOrNaN(amount);
-        if (amount == 1.0d) {
+    public RoundedMoney multiply(double multiplicand) {
+        Money.checkNoInfinityOrNaN(multiplicand);
+        if (multiplicand == 1.0d) {
             return this;
         }
-        return multiply(MoneyUtils.getBigDecimal(amount));
+        return multiply(MoneyUtils.getBigDecimal(multiplicand));
     }
 
     @Override
-    public RoundedMoney divide(long amount) {
-        if (amount == 1L) {
+    public RoundedMoney divide(long divisor) {
+        if (divisor == 1L) {
             return this;
         }
-        return divide(MoneyUtils.getBigDecimal(amount));
+        return divide(MoneyUtils.getBigDecimal(divisor));
     }
 
     @Override
-    public RoundedMoney divide(double amount) {
-        if (Money.isInfinityAndNotNaN(amount)) {
+    public RoundedMoney divide(double divisor) {
+        if (Money.isInfinityAndNotNaN(divisor)) {
             return new RoundedMoney(0L, getCurrency(), this.monetaryContext, this.rounding);
         }
-        if (amount == 1.0d) {
+        if (divisor == 1.0d) {
             return this;
         }
-        return divide(MoneyUtils.getBigDecimal(amount));
+        return divide(MoneyUtils.getBigDecimal(divisor));
     }
 
     @Override
-    public RoundedMoney remainder(long amount) {
-        return remainder(MoneyUtils.getBigDecimal(amount));
+    public RoundedMoney remainder(long divisor) {
+        return remainder(MoneyUtils.getBigDecimal(divisor));
     }
 
     @Override
-    public RoundedMoney remainder(double amount) {
-        if (Money.isInfinityAndNotNaN(amount)) {
+    public RoundedMoney remainder(double divisor) {
+        if (Money.isInfinityAndNotNaN(divisor)) {
             return new RoundedMoney(0L, getCurrency(), this.monetaryContext, this.rounding);
         }
-        return remainder(MoneyUtils.getBigDecimal(amount));
+        return remainder(MoneyUtils.getBigDecimal(divisor));
     }
 
     @Override
-    public RoundedMoney[] divideAndRemainder(long amount) {
-        return divideAndRemainder(MoneyUtils.getBigDecimal(amount));
+    public RoundedMoney[] divideAndRemainder(long divisor) {
+        return divideAndRemainder(MoneyUtils.getBigDecimal(divisor));
     }
 
     @Override
-    public RoundedMoney[] divideAndRemainder(double amount) {
-        if (Money.isInfinityAndNotNaN(amount)) {
+    public RoundedMoney[] divideAndRemainder(double divisor) {
+        if (Money.isInfinityAndNotNaN(divisor)) {
             RoundedMoney zero = new RoundedMoney(0L, getCurrency(), this.monetaryContext, this.rounding);
             return new RoundedMoney[]{zero, zero};
         }
-        return divideAndRemainder(MoneyUtils.getBigDecimal(amount));
+        return divideAndRemainder(MoneyUtils.getBigDecimal(divisor));
     }
 
     @Override