/*

  * Copyright (c) 2003, 2007, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 /*

  * Portions Copyright IBM Corporation, 1997, 2001. All Rights Reserved.

  */

 package java.math;

 import java.io.*;

 /**

  * Immutable objects which encapsulate the context settings which

  * describe certain rules for numerical operators, such as those

  * implemented by the {@link BigDecimal} class.

  *

  * <p>The base-independent settings are:

  * <ol>

  * <li>{@code precision}:

  * the number of digits to be used for an operation; results are

  * rounded to this precision

  *

  * <li>{@code roundingMode}:

  * a {@link RoundingMode} object which specifies the algorithm to be

  * used for rounding.

  * </ol>

  *

  * @see     BigDecimal

  * @see     RoundingMode

  * @author  Mike Cowlishaw

  * @author  Joseph D. Darcy

  * @since 1.5

  */

 public final class MathContext implements Serializable {

     /* ----- Constants ----- */

     // defaults for constructors

     private static final int DEFAULT_DIGITS = 9;

     private static final RoundingMode DEFAULT_ROUNDINGMODE = RoundingMode.HALF_UP;

     // Smallest values for digits (Maximum is Integer.MAX_VALUE)

     private static final int MIN_DIGITS = 0;

     // Serialization version

     private static final long serialVersionUID = 5579720004786848255L;

     /* ----- Public Properties ----- */

     /**

      *  A {@code MathContext} object whose settings have the values

      *  required for unlimited precision arithmetic.

      *  The values of the settings are:

      *  <code>

      *  precision=0 roundingMode=HALF_UP

      *  </code>

      */

     public static final MathContext UNLIMITED =

         new MathContext(0, RoundingMode.HALF_UP);

     /**

      *  A {@code MathContext} object with a precision setting

      *  matching the IEEE 754R Decimal32 format, 7 digits, and a

      *  rounding mode of {@link RoundingMode#HALF_EVEN HALF_EVEN}, the

      *  IEEE 754R default.

      */

     public static final MathContext DECIMAL32 =

         new MathContext(7, RoundingMode.HALF_EVEN);

     /**

      *  A {@code MathContext} object with a precision setting

      *  matching the IEEE 754R Decimal64 format, 16 digits, and a

      *  rounding mode of {@link RoundingMode#HALF_EVEN HALF_EVEN}, the

      *  IEEE 754R default.

      */

     public static final MathContext DECIMAL64 =

         new MathContext(16, RoundingMode.HALF_EVEN);

     /**

      *  A {@code MathContext} object with a precision setting

      *  matching the IEEE 754R Decimal128 format, 34 digits, and a

      *  rounding mode of {@link RoundingMode#HALF_EVEN HALF_EVEN}, the

      *  IEEE 754R default.

      */

     public static final MathContext DECIMAL128 =

         new MathContext(34, RoundingMode.HALF_EVEN);

     /* ----- Shared Properties ----- */

     /**

      * The number of digits to be used for an operation.  A value of 0

      * indicates that unlimited precision (as many digits as are

      * required) will be used.  Note that leading zeros (in the

      * coefficient of a number) are never significant.

      *

      * <p>{@code precision} will always be non-negative.

      *

      * @serial

      */

     final int precision;

     /**

      * The rounding algorithm to be used for an operation.

      *

      * @see RoundingMode

      * @serial

      */

     final RoundingMode roundingMode;

     /* ----- Constructors ----- */

     /**

      * Constructs a new {@code MathContext} with the specified

      * precision and the {@link RoundingMode#HALF_UP HALF_UP} rounding

      * mode.

      *

      * @param setPrecision The non-negative {@code int} precision setting.

      * @throws IllegalArgumentException if the {@code setPrecision} parameter is less

      *         than zero.

      */

     public MathContext(int setPrecision) {

         this(setPrecision, DEFAULT_ROUNDINGMODE);

         return;

     }

     /**

      * Constructs a new {@code MathContext} with a specified

      * precision and rounding mode.

      *

      * @param setPrecision The non-negative {@code int} precision setting.

      * @param setRoundingMode The rounding mode to use.

      * @throws IllegalArgumentException if the {@code setPrecision} parameter is less

      *         than zero.

      * @throws NullPointerException if the rounding mode argument is {@code null}

      */

     public MathContext(int setPrecision,

                        RoundingMode setRoundingMode) {

         if (setPrecision < MIN_DIGITS)

             throw new IllegalArgumentException("Digits < 0");

         if (setRoundingMode == null)

             throw new NullPointerException("null RoundingMode");

         precision = setPrecision;

         roundingMode = setRoundingMode;

         return;

     }

     /**

      * Constructs a new {@code MathContext} from a string.

      *

      * The string must be in the same format as that produced by the

      * {@link #toString} method.

      *

      * <p>An {@code IllegalArgumentException} is thrown if the precision

      * section of the string is out of range ({@code < 0}) or the string is

      * not in the format created by the {@link #toString} method.

      *

      * @param val The string to be parsed

      * @throws IllegalArgumentException if the precision section is out of range

      * or of incorrect format

      * @throws NullPointerException if the argument is {@code null}

      */

     public MathContext(String val) {

         boolean bad = false;

         int setPrecision;

         if (val == null)

             throw new NullPointerException("null String");

         try { // any error here is a string format problem

             if (!val.startsWith("precision=")) throw new RuntimeException();

             int fence = val.indexOf(' ');    // could be -1

             int off = 10;                     // where value starts

             setPrecision = Integer.parseInt(val.substring(10, fence));

             if (!val.startsWith("roundingMode=", fence+1))

                 throw new RuntimeException();

             off = fence + 1 + 13;

             String str = val.substring(off, val.length());

             roundingMode = RoundingMode.valueOf(str);

         } catch (RuntimeException re) {

             throw new IllegalArgumentException("bad string format");

         }

         if (setPrecision < MIN_DIGITS)

             throw new IllegalArgumentException("Digits < 0");

         // the other parameters cannot be invalid if we got here

         precision = setPrecision;

     }

     /**

      * Returns the {@code precision} setting.

      * This value is always non-negative.

      *

      * @return an {@code int} which is the value of the {@code precision}

      *         setting

      */

     public int getPrecision() {

         return precision;

     }

     /**

      * Returns the roundingMode setting.

      * This will be one of

      * {@link  RoundingMode#CEILING},

      * {@link  RoundingMode#DOWN},

      * {@link  RoundingMode#FLOOR},

      * {@link  RoundingMode#HALF_DOWN},

      * {@link  RoundingMode#HALF_EVEN},

      * {@link  RoundingMode#HALF_UP},

      * {@link  RoundingMode#UNNECESSARY}, or

      * {@link  RoundingMode#UP}.

      *

      * @return a {@code RoundingMode} object which is the value of the

      *         {@code roundingMode} setting

      */

     public RoundingMode getRoundingMode() {

         return roundingMode;

     }

     /**

      * Compares this {@code MathContext} with the specified

      * {@code Object} for equality.

      *

      * @param  x {@code Object} to which this {@code MathContext} is to

      *         be compared.

      * @return {@code true} if and only if the specified {@code Object} is

      *         a {@code MathContext} object which has exactly the same

      *         settings as this object

      */

     public boolean equals(Object x){

         MathContext mc;

         if (!(x instanceof MathContext))

             return false;

         mc = (MathContext) x;

         return mc.precision == this.precision

             && mc.roundingMode == this.roundingMode; // no need for .equals()

     }

     /**

      * Returns the hash code for this {@code MathContext}.

      *

      * @return hash code for this {@code MathContext}

      */

     public int hashCode() {

         return this.precision + roundingMode.hashCode() * 59;

     }

     /**

      * Returns the string representation of this {@code MathContext}.

      * The {@code String} returned represents the settings of the

      * {@code MathContext} object as two space-delimited words

      * (separated by a single space character, <tt>'&#92;u0020'</tt>,

      * and with no leading or trailing white space), as follows:

      * <ol>

      * <li>

      * The string {@code "precision="}, immediately followed

      * by the value of the precision setting as a numeric string as if

      * generated by the {@link Integer#toString(int) Integer.toString}

      * method.

      *

      * <li>

      * The string {@code "roundingMode="}, immediately

      * followed by the value of the {@code roundingMode} setting as a

      * word.  This word will be the same as the name of the

      * corresponding public constant in the {@link RoundingMode}

      * enum.

      * </ol>

      * <p>

      * For example:

      * <pre>

      * precision=9 roundingMode=HALF_UP

      * </pre>

      *

      * Additional words may be appended to the result of

      * {@code toString} in the future if more properties are added to

      * this class.

      *

      * @return a {@code String} representing the context settings

      */

     public java.lang.String toString() {

         return "precision=" +           precision + " " +

                "roundingMode=" +        roundingMode.toString();

     }

     // Private methods

     /**

      * Reconstitute the {@code MathContext} instance from a stream (that is,

      * deserialize it).

      *

      * @param s the stream being read.

      */

     private void readObject(java.io.ObjectInputStream s)

         throws java.io.IOException, ClassNotFoundException {

         s.defaultReadObject();     // read in all fields

         // validate possibly bad fields

         if (precision < MIN_DIGITS) {

             String message = "MathContext: invalid digits in stream";

             throw new java.io.StreamCorruptedException(message);

         }

         if (roundingMode == null) {

             String message = "MathContext: null roundingMode in stream";

             throw new java.io.StreamCorruptedException(message);

         }

     }

 }