View Javadoc
1 package attrib4j; 2 3 import java.io.PrintStream; 4 import java.io.PrintWriter; 5 import java.io.StringWriter; 6 7 /*** 8 * It allows you nest exceptions. This results in simplifing the 9 * external API of a package or library. 10 * 11 * Implementation inspired from various placed, most recently 12 * Javaworld, Javatips #91. Now included as part of J2SE 1.4 13 * 14 * @author <a href="mailto:mpollack@speakeasy.net">Mark Pollack</a> 15 * @version $Revision: 1.4 $ $Date: 2003/03/22 17:56:20 $ 16 */ 17 public class AttributeException extends Exception { 18 19 /* 20 * By giving <code>AttributeException</code> a reference to a 21 * Throwable object, exception chaining can be enforced easily. 22 */ 23 private Throwable _previousThrowable = null; 24 25 /*** 26 * The yucky stack trace string. 27 * 28 */ 29 private String _stackTraceString; 30 31 /*** 32 * Do nothing constructor. 33 * 34 */ 35 public AttributeException() { 36 } 37 38 /*** 39 * Creates a new <code>AttributeException</code> instance. 40 * @param message a <code>String</code> value 41 */ 42 public AttributeException(String message) { 43 super(message); 44 } 45 46 /*** 47 * Create an exception nesting the rootCause of this exception. 48 * 49 * @param rootCause a value of type 'Throwable'. 50 */ 51 public AttributeException(Throwable rootCause) { 52 super(); 53 if (rootCause != null) { 54 _previousThrowable = rootCause; 55 _stackTraceString = generateStackTraceString(rootCause); 56 } else { 57 _previousThrowable = 58 new Exception( 59 "ERROR: A null value for rootCause was passed " 60 + "to the constructor of AttributeException"); 61 _stackTraceString = generateStackTraceString(_previousThrowable); 62 } 63 } 64 65 /*** 66 * Create a new <code>AttributeException</code> instance. Allows for 67 * an association of an originating exception. 68 * 69 * @param message Message of the exception. 70 * message of the exception. 71 * @param rootCause The exception that caused this exception to be raised. 72 */ 73 public AttributeException(String message, Throwable rootCause) { 74 super(message); 75 if (rootCause != null) { 76 _previousThrowable = rootCause; 77 _stackTraceString = generateStackTraceString(rootCause); 78 } else { 79 _previousThrowable = 80 new Exception( 81 "ERROR: A null value for rootCause was passed " 82 + "to the constructor of AttributeException"); 83 _stackTraceString = generateStackTraceString(_previousThrowable); 84 } 85 } 86 87 /*** 88 * Get the exception that caused this exception to be raised. 89 * 90 * @return the root exception. 91 */ 92 public Throwable getRootCause() { 93 return _previousThrowable; 94 } 95 96 /*** 97 * Return the stack trace including root cause exceptions. 98 * 99 * @return The stack trace of the exception. 100 */ 101 public String getStackTraceString() { 102 // if there's no nested exception, there's no stackTrace 103 if (_previousThrowable == null) { 104 return null; 105 } 106 107 StringBuffer traceBuffer = new StringBuffer(); 108 109 if (_previousThrowable instanceof AttributeException) { 110 111 traceBuffer.append( 112 ((AttributeException) _previousThrowable) 113 .getStackTraceString()); 114 traceBuffer.append("-------- nested by:\n"); 115 } 116 117 traceBuffer.append(_stackTraceString); 118 return traceBuffer.toString(); 119 } 120 121 /*** 122 * Override Exceptipn.getMessage to include information of the root 123 * cause of the exception. 124 * 125 * @return The exception message, including root cause messages. 126 */ 127 public String getMessage() { 128 // superMsg will contain whatever String was passed into the 129 // constructor, and null otherwise. 130 String superMsg = super.getMessage(); 131 132 // if there's no nested exception, do like we would always do 133 if (getRootCause() == null) { 134 return superMsg; 135 } 136 137 StringBuffer theMsg = new StringBuffer(); 138 139 // get the nested exception's message 140 String nestedMsg = getRootCause().getMessage(); 141 142 if (superMsg != null) { 143 theMsg.append(superMsg).append(": ").append(nestedMsg); 144 } else { 145 theMsg.append(nestedMsg); 146 } 147 148 return theMsg.toString(); 149 } 150 151 /* 152 * Print out the nested exception. 153 * @see java.lang.Object#toString() 154 */ 155 public String toString() { 156 StringBuffer theMsg = new StringBuffer(super.toString()); 157 158 if (getRootCause() != null) { 159 theMsg.append("; \n\t---> nested ").append(getRootCause()); 160 } 161 162 return theMsg.toString(); 163 } 164 165 /*** 166 * Override default behavior 167 * 168 */ 169 public void printStackTrace() { 170 super.printStackTrace(); 171 if (_previousThrowable != null) { 172 _previousThrowable.printStackTrace(); 173 } 174 } 175 176 /*** 177 * Override default behavior 178 * 179 */ 180 public void printStackTrace(PrintStream inPrintStream) { 181 super.printStackTrace(inPrintStream); 182 if (_previousThrowable != null) { 183 _previousThrowable.printStackTrace(inPrintStream); 184 } 185 } 186 187 /*** 188 * Override default behavior 189 * 190 */ 191 public void printStackTrace(PrintWriter inPrintWriter) { 192 super.printStackTrace(inPrintWriter); 193 if (_previousThrowable != null) { 194 _previousThrowable.printStackTrace(inPrintWriter); 195 } 196 } 197 198 /*** 199 * Generate the StackTraceString 200 * 201 * @param t a <code>Throwable</code> value 202 * @return a <code>String</code> value 203 */ 204 private static String generateStackTraceString(Throwable t) { 205 StringWriter s = new StringWriter(); 206 t.printStackTrace(new PrintWriter(s)); 207 return s.toString(); 208 209 } 210 211 }

This page was automatically generated by Maven