001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.lang.exception; 018 019 import java.io.PrintStream; 020 import java.io.PrintWriter; 021 022 /** 023 * The base class of all runtime exceptions which can contain other 024 * exceptions. 025 * 026 * @see org.apache.commons.lang.exception.NestableException 027 * @author <a href="mailto:Rafal.Krzewski@e-point.pl">Rafal Krzewski</a> 028 * @author Daniel L. Rall 029 * @author <a href="mailto:knielsen@apache.org">Kasper Nielsen</a> 030 * @author <a href="mailto:steven@caswell.name">Steven Caswell</a> 031 * @since 1.0 032 * @version $Id: NestableRuntimeException.java 512889 2007-02-28 18:18:20Z dlr $ 033 */ 034 public class NestableRuntimeException extends RuntimeException implements Nestable { 035 036 /** 037 * Required for serialization support. 038 * 039 * @see java.io.Serializable 040 */ 041 private static final long serialVersionUID = 1L; 042 043 /** 044 * The helper instance which contains much of the code which we 045 * delegate to. 046 */ 047 protected NestableDelegate delegate = new NestableDelegate(this); 048 049 /** 050 * Holds the reference to the exception or error that caused 051 * this exception to be thrown. 052 */ 053 private Throwable cause = null; 054 055 /** 056 * Constructs a new <code>NestableRuntimeException</code> without specified 057 * detail message. 058 */ 059 public NestableRuntimeException() { 060 super(); 061 } 062 063 /** 064 * Constructs a new <code>NestableRuntimeException</code> with specified 065 * detail message. 066 * 067 * @param msg the error message 068 */ 069 public NestableRuntimeException(String msg) { 070 super(msg); 071 } 072 073 /** 074 * Constructs a new <code>NestableRuntimeException</code> with specified 075 * nested <code>Throwable</code>. 076 * 077 * @param cause the exception or error that caused this exception to be 078 * thrown 079 */ 080 public NestableRuntimeException(Throwable cause) { 081 super(); 082 this.cause = cause; 083 } 084 085 /** 086 * Constructs a new <code>NestableRuntimeException</code> with specified 087 * detail message and nested <code>Throwable</code>. 088 * 089 * @param msg the error message 090 * @param cause the exception or error that caused this exception to be 091 * thrown 092 */ 093 public NestableRuntimeException(String msg, Throwable cause) { 094 super(msg); 095 this.cause = cause; 096 } 097 098 /** 099 * {@inheritDoc} 100 */ 101 public Throwable getCause() { 102 return cause; 103 } 104 105 /** 106 * Returns the detail message string of this throwable. If it was 107 * created with a null message, returns the following: 108 * (cause==null ? null : cause.toString()). 109 * 110 * @return String message string of the throwable 111 */ 112 public String getMessage() { 113 if (super.getMessage() != null) { 114 return super.getMessage(); 115 } else if (cause != null) { 116 return cause.toString(); 117 } else { 118 return null; 119 } 120 } 121 122 /** 123 * {@inheritDoc} 124 */ 125 public String getMessage(int index) { 126 if (index == 0) { 127 return super.getMessage(); 128 } 129 return delegate.getMessage(index); 130 } 131 132 /** 133 * {@inheritDoc} 134 */ 135 public String[] getMessages() { 136 return delegate.getMessages(); 137 } 138 139 /** 140 * {@inheritDoc} 141 */ 142 public Throwable getThrowable(int index) { 143 return delegate.getThrowable(index); 144 } 145 146 /** 147 * {@inheritDoc} 148 */ 149 public int getThrowableCount() { 150 return delegate.getThrowableCount(); 151 } 152 153 /** 154 * {@inheritDoc} 155 */ 156 public Throwable[] getThrowables() { 157 return delegate.getThrowables(); 158 } 159 160 /** 161 * {@inheritDoc} 162 */ 163 public int indexOfThrowable(Class type) { 164 return delegate.indexOfThrowable(type, 0); 165 } 166 167 /** 168 * {@inheritDoc} 169 */ 170 public int indexOfThrowable(Class type, int fromIndex) { 171 return delegate.indexOfThrowable(type, fromIndex); 172 } 173 174 /** 175 * {@inheritDoc} 176 */ 177 public void printStackTrace() { 178 delegate.printStackTrace(); 179 } 180 181 /** 182 * {@inheritDoc} 183 */ 184 public void printStackTrace(PrintStream out) { 185 delegate.printStackTrace(out); 186 } 187 188 /** 189 * {@inheritDoc} 190 */ 191 public void printStackTrace(PrintWriter out) { 192 delegate.printStackTrace(out); 193 } 194 195 /** 196 * {@inheritDoc} 197 */ 198 public final void printPartialStackTrace(PrintWriter out) { 199 super.printStackTrace(out); 200 } 201 202 }