/*

 * 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);

        }

    }

}