From 2ac0eb8cd7f4d22c6a955abf836bbc43352443da Mon Sep 17 00:00:00 2001
From: Phil Steitz <psteitz@apache.org>
Date: Sat, 10 Jul 2004 22:21:36 +0000
Subject: [PATCH] Eliminated [lang] dependency.

git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/math/trunk@141372 13f79535-47bb-0310-9956-ffa450edef68
---
 .../apache/commons/math/MathException.java    | 150 ++++++++++++++----
 1 file changed, 118 insertions(+), 32 deletions(-)

diff --git a/src/java/org/apache/commons/math/MathException.java b/src/java/org/apache/commons/math/MathException.java
index 6f2c363b5..d7ee962f7 100644
--- a/src/java/org/apache/commons/math/MathException.java
+++ b/src/java/org/apache/commons/math/MathException.java
@@ -16,47 +16,133 @@
 package org.apache.commons.math;
 
 import java.io.Serializable;
+import java.io.PrintStream;
+import java.io.PrintWriter;
 
-import org.apache.commons.lang.exception.NestableException;
 
 /**
- * A generic exception indicating problems in the math package.
- * @version $Revision: 1.17 $ $Date: 2004/06/23 16:26:16 $
- */
-public class MathException extends NestableException implements Serializable {
-
+* Base exception class for commons-math.
+* <p>
+* Supports nesting, emulating JDK 1.4 behavior if necessary.  
+* <p>
+* Adapted from {@link org.apache.commons.collections.FunctorException}.
+* 
+* @version $Revision: 1.18 $ $Date: 2004/07/10 22:21:36 $
+*/
+public class MathException extends Exception {
+    
     /** Serializable version identifier */
     static final long serialVersionUID = -8594613561393443827L;
     
     /**
-     * Constructs a MathException
+     * Does JDK support nested exceptions?
+     */
+    private static final boolean JDK_SUPPORTS_NESTED;
+    
+    static {
+        boolean flag = false;
+        try {
+            Throwable.class.getDeclaredMethod("getCause", new Class[0]);
+            flag = true;
+        } catch (NoSuchMethodException ex) {
+            flag = false;
+        }
+        JDK_SUPPORTS_NESTED = flag;
+    }
+    
+    /**
+     * Root cause of the exception
+     */
+    private final Throwable rootCause;
+    
+    /**
+     * Constructs a new <code>MathException</code> with no
+     * detail message.
      */
     public MathException() {
-        this(null, null);
+        super();
+        this.rootCause = null;
+    }
+    
+    /**
+     * Constructs a new <code>MathException</code> with specified
+     * detail message.
+     *
+     * @param msg  the error message.
+     */
+    public MathException(String msg) {
+        super(msg);
+        this.rootCause = null;
+    }
+    
+    /**
+     * Constructs a new <code>MathException</code> with specified
+     * nested <code>Throwable</code> root cause.
+     *
+     * @param rootCause  the exception or error that caused this exception
+     *                   to be thrown.
+     */
+    public MathException(Throwable rootCause) {
+        super((rootCause == null ? null : rootCause.getMessage()));
+        this.rootCause = rootCause;
+    }
+    
+    /**
+     * Constructs a new <code>MathException</code> with specified
+     * detail message and nested <code>Throwable</code> root cause.
+     *
+     * @param msg  the error message.
+     * @param rootCause  the exception or error that caused this exception
+     *                   to be thrown.
+     */
+    public MathException(String msg, Throwable rootCause) {
+        super(msg);
+        this.rootCause = rootCause;
+    }
+    
+    /**
+     * Gets the cause of this throwable.
+     * 
+     * @return  the cause of this throwable, or <code>null</code>
+     */
+    public Throwable getCause() {
+        return rootCause;
+    }
+    
+    /**
+     * Prints the stack trace of this exception to the standard error stream.
+     */
+    public void printStackTrace() {
+        printStackTrace(System.err);
+    }
+    
+    /**
+     * Prints the stack trace of this exception to the specified stream.
+     *
+     * @param out  the <code>PrintStream</code> to use for output
+     */
+    public void printStackTrace(PrintStream out) {
+        synchronized (out) {
+            PrintWriter pw = new PrintWriter(out, false);
+            printStackTrace(pw);
+            // Flush the PrintWriter before it's GC'ed.
+            pw.flush();
+        }
+    }
+    
+    /**
+     * Prints the stack trace of this exception to the specified writer.
+     *
+     * @param out  the <code>PrintWriter</code> to use for output
+     */
+    public void printStackTrace(PrintWriter out) {
+        synchronized (out) {
+            super.printStackTrace(out);
+            if (rootCause != null && JDK_SUPPORTS_NESTED == false) {
+                out.print("Caused by: ");
+                rootCause.printStackTrace(out);
+            }
+        }
     }
 
-    /**
-     * Create an exception with a given error message.
-     * @param message message describing the problem
-     */
-    public MathException(final String message) {
-        this(message, null);
-    }
-
-    /**
-     * Create an exception with a given error message and root cause.
-     * @param message message describing the problem
-     * @param throwable caught exception causing this problem
-     */
-    public MathException(final String message, final Throwable throwable) {
-        super(message, throwable);
-    }
-
-    /**
-     * Create an exception with a given root cause.
-     * @param throwable caught exception causing this problem
-     */
-    public MathException(final Throwable throwable) {
-        this(null, throwable);
-    }
 }