MelatiException.java

  1. /*
  2.  * $Source$
  3.  * $Revision$
  4.  *
  5.  * Copyright (C) 2000 William Chesters
  6.  *
  7.  * Part of Melati (http://melati.org), a framework for the rapid
  8.  * development of clean, maintainable web applications.
  9.  *
  10.  * Melati is free software; Permission is granted to copy, distribute
  11.  * and/or modify this software under the terms either:
  12.  *
  13.  * a) the GNU General Public License as published by the Free Software
  14.  *    Foundation; either version 2 of the License, or (at your option)
  15.  *    any later version,
  16.  *
  17.  *    or
  18.  *
  19.  * b) any version of the Melati Software License, as published
  20.  *    at http://melati.org
  21.  *
  22.  * You should have received a copy of the GNU General Public License and
  23.  * the Melati Software License along with this program;
  24.  * if not, write to the Free Software Foundation, Inc.,
  25.  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
  26.  * GNU General Public License and visit http://melati.org to obtain the
  27.  * Melati Software License.
  28.  *
  29.  * Feel free to contact the Developers of Melati (http://melati.org),
  30.  * if you would like to work out a different arrangement than the options
  31.  * outlined here.  It is our intention to allow Melati to be used by as
  32.  * wide an audience as possible.
  33.  *
  34.  * This program is distributed in the hope that it will be useful,
  35.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  36.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  37.  * GNU General Public License for more details.
  38.  *
  39.  * Contact details for copyright holder:
  40.  *
  41.  *     William Chesters <williamc At paneris.org>
  42.  *     http://paneris.org/~williamc
  43.  *     Obrechtstraat 114, 2517VX Den Haag, The Netherlands
  44.  */

  45. package org.melati.util;

  46. /**
  47.  * Abstract base class for all <code>Exception</code>s within
  48.  * Melati.
  49.  */
  50. public abstract class MelatiException extends Exception {

  51.   /**
  52.    * Eclipse generated.
  53.    */
  54.   private static final long serialVersionUID = -5635532269280872906L;
  55.  
  56.   /** A sub-exception we may be wrapping, otherwise null. */
  57.   public Exception subException;

  58.   /** Constructor with sub-exception. */
  59.   public MelatiException(Exception subException) {
  60.     this.subException = subException;
  61.   }
  62.   /**
  63.    * Constructor with message and pre-java 1.4 initial cause.
  64.    */
  65.   public MelatiException(String message, Exception subException) {
  66.     super(message);
  67.     initCause(subException);
  68.   }

  69.   /**
  70.    * Constructor.
  71.    */
  72.   public MelatiException() {
  73.     this((Exception)null);
  74.   }

  75.   /**
  76.    * Constructor with message.
  77.    * @param message a text
  78.    */
  79.   public MelatiException(String message) {
  80.     super(message);
  81.   }
  82.   /**
  83.    * {@inheritDoc}
  84.    * @see java.lang.Throwable#getMessage()
  85.    */
  86.   public String getMessage() {
  87.     return this.getClass().getName() +
  88.     (super.getMessage() == null ? "" : ": " + super.getMessage()) +
  89.     (subException == null ? "" : "\n" + subException);
  90.   }

  91.   /**
  92.    * @return the actual cause
  93.    */
  94.   public Exception innermostException() {
  95.     return subException == null ? this :
  96.            subException instanceof MelatiException ?
  97.                ((MelatiException)subException).innermostException() :
  98.            subException instanceof MelatiRuntimeException ?
  99.                ((MelatiRuntimeException)subException).innermostException() :
  100.            subException;
  101.   }

  102.   /**
  103.    * {@inheritDoc}
  104.    * @see java.lang.Throwable#printStackTrace()
  105.    */
  106.   public void printStackTrace() {
  107.     if (subException == null)
  108.       super.printStackTrace();
  109.     else {
  110.       System.err.println(this);
  111.       System.err.println("---");
  112.       innermostException().printStackTrace();
  113.     }
  114.   }

  115.   /**
  116.    * {@inheritDoc}
  117.    * @see java.lang.Throwable#printStackTrace(java.io.PrintStream)
  118.    */
  119.   public void printStackTrace(java.io.PrintStream s) {
  120.     if (subException == null)
  121.       super.printStackTrace(s);
  122.     else {
  123.       s.println(this);
  124.       s.println("---");
  125.       innermostException().printStackTrace(s);
  126.     }
  127.   }

  128.   /**
  129.    * {@inheritDoc}
  130.    * @see java.lang.Throwable#printStackTrace(java.io.PrintWriter)
  131.    */
  132.   public void printStackTrace(java.io.PrintWriter w) {
  133.     if (subException == null)
  134.       super.printStackTrace(w);
  135.     else {
  136.       w.println(this);
  137.       w.println("---");
  138.       innermostException().printStackTrace(w);
  139.     }
  140.   }
  141. }