/*
 * @(#)MathContext.java	1.2 03/12/19
 *
 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

/*
 * @(#)MathContext.java  1.x 01/xx/xx
 *
 * Copyright IBM Corporation, 1997, 2001. All Rights Reserved.
 *
 * This software is the proprietary information of Sun Microsystems, Inc.
 * and IBM Corporation.  Use is subject to license terms.
 *
 */

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><tt>precision</tt>:
 * the number of digits to be used for an operation; results are
 * rounded to this precision
 * 
 * <li><tt>roundingMode</tt>:
 * 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
 */

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 <tt>MathContext</tt> 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 <tt>MathContext</tt> 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 <tt>MathContext</tt> 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 <tt>MathContext</tt> 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><tt>precision</tt> will always be non-negative.
     *
     * @serial
     */
    final int precision;

    /**
     * The rounding algorithm to be used for an operation.
     *
     * @see RoundingMode
     * @serial
     */
    final RoundingMode roundingMode;

    /**
     *  Lookaside for the rounding points (the numbers which determine
     *  whether the coefficient of a number will require rounding).
     *  These will be present if precision>0 and
     *  precision<=MAX_LOOKASIDE.  In this case they will share the
     *  <tt>BigInteger int[]</tt> array.  Note that the transients
     *  cannot be <tt>final</tt> because they are reconstructed on
     *  deserialization.
     */
    transient BigInteger roundingMax = null;
    transient BigInteger roundingMin = null;
    private static final int MAX_LOOKASIDE = 1000;

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

    /**
     * Constructs a new <tt>MathContext</tt> with the specified
     * precision and the {@link RoundingMode#HALF_UP HALF_UP} rounding
     * mode.
     *
     * @param setPrecision The non-negative <tt>int</tt> precision setting.
     * @throws IllegalArgumentException <tt>setPrecision</tt> parameter less 
     *         than zero.
     */
    public MathContext(int setPrecision) {
        this(setPrecision, DEFAULT_ROUNDINGMODE);
        return;
    }

    /**
     * Constructs a new <tt>MathContext</tt> with a specified
     * precision and rounding mode.
     *
     * @param setPrecision The non-negative <tt>int</tt> precision setting.
     * @param setRoundingMode The rounding mode to use.
     * @throws IllegalArgumentException <tt>setPrecision</tt> parameter less 
     *         than zero.
     */
    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;
        if (precision > 0 && precision <= MAX_LOOKASIDE) {
            roundingMax = BigInteger.TEN.pow(precision);
            roundingMin = roundingMax.negate();
        }

        roundingMode = setRoundingMode;
        return;
    }

    /**
     * Constructs a new <tt>MathContext</tt> from a string.
     *
     * The string must be in the same format as that produced by the
     * {@link #toString} method.
     * 
     * <p>An <tt>IllegalArgumentException</tt> is thrown if the precision
     * section of the string is out of range (< 0) or the string is
     * not in the format created by the {@link #toString} method.
     *
     * @param val The string to be parsed
     * @throws IllegalArgumentException precision parameter out of range
     * or incorrect format
     */
    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;
        if (precision > 0 && precision <= MAX_LOOKASIDE) {
            roundingMax = BigInteger.TEN.pow(precision);
            roundingMin = roundingMax.negate();
        }
    }

    /**
     * Returns the <tt>precision</tt> setting.
     * This value is always non-negative.
     *
     * @return an <tt>int</tt> which is the value of the <tt>precision</tt>
     *         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 <tt>RoundingMode</tt> object which is the value of the
     *         <tt>roundingMode</tt> setting
     */

    public RoundingMode getRoundingMode() {
        return roundingMode;
    }

    /**
     * Compares this <tt>MathContext</tt> with the specified
     * <tt>Object</tt> for equality.
     *
     * @param  x <tt>Object</tt> to which this <tt>MathContext</tt> is to 
     *         be compared.
     * @return <tt>true</tt> if and only if the specified <tt>Object</tt> is
     *         a <tt>MathContext</tt> 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 <tt>MathContext</tt>.
     *
     * @return hash code for this <tt>MathContext</tt>
     */
    public int hashCode() {
        return this.precision + roundingMode.hashCode() * 59;
    }

    /** 
     * Returns the string representation of this <tt>MathContext</tt>.
     * The <tt>String</tt> returned represents the settings of the
     * <tt>MathContext</tt> object as two space-delimited words
     * (separated by a single space character, <tt>'\u0020'</tt>,
     * and with no leading or trailing white space), as follows:
     * <ol>
     * <li>
     * The string <tt>"precision="</tt>, 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 <tt>"roundingMode="</tt>, immediately
     * followed by the value of the <tt>roundingMode</tt> 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
     * <tt>toString</tt> in the future if more properties are added to
     * this class.
     *
     * @return a <tt>String</tt> representing the context settings.
     */
    public java.lang.String toString() {
        return "precision=" +		precision + " " +
	       "roundingMode=" +	roundingMode.toString();
    }

    // Private methods

    /**
     * Reconstitute the <tt>MathContext</tt> instance from a stream (that is,
     * deserialize it).
     *
     * @param s the stream being read.
     */
    private synchronized 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);
        }
        // Set the lookaside, if applicable
        if (precision <= MAX_LOOKASIDE) {
            roundingMax = BigInteger.TEN.pow(precision);
            roundingMin = roundingMax.negate();
        }
    }

}