1 package org.apache.commons.ognl; 2 3 /* 4 * Licensed to the Apache Software Foundation (ASF) under one 5 * or more contributor license agreements. See the NOTICE file 6 * distributed with this work for additional information 7 * regarding copyright ownership. The ASF licenses this file 8 * to you under the Apache License, Version 2.0 (the 9 * "License"); you may not use this file except in compliance 10 * with the License. You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, 15 * software distributed under the License is distributed on an 16 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 17 * KIND, either express or implied. See the License for the 18 * specific language governing permissions and limitations 19 * under the License. 20 */ 21 22 import java.lang.reflect.Method; 23 24 /** 25 * Superclass for OGNL exceptions, incorporating an optional encapsulated exception. 26 * 27 * @author Luke Blanshard (blanshlu@netscape.net) 28 * @author Drew Davidson (drew@ognl.org) 29 */ 30 public class OgnlException 31 extends Exception 32 { 33 // cache initCause method - if available..to be used during throwable constructor 34 // to properly setup superclass. 35 36 private static final long serialVersionUID = -842845048743721078L; 37 38 static Method initCause; 39 static 40 { 41 try 42 { 43 initCause = OgnlException.class.getMethod( "initCause", new Class[] { Throwable.class } ); 44 } 45 catch ( NoSuchMethodException e ) 46 { 47 /** ignore */ 48 } 49 } 50 51 /** 52 * The root evaluation of the expression when the exception was thrown 53 */ 54 private Evaluation evaluation; 55 56 /** 57 * Why this exception was thrown. 58 * 59 * @serial 60 */ 61 private Throwable reason; 62 63 /** Constructs an OgnlException with no message or encapsulated exception. */ 64 public OgnlException() 65 { 66 this( null, null ); 67 } 68 69 /** 70 * Constructs an OgnlException with the given message but no encapsulated exception. 71 * 72 * @param msg the exception's detail message 73 */ 74 public OgnlException( String msg ) 75 { 76 this( msg, null ); 77 } 78 79 /** 80 * Constructs an OgnlException with the given message and encapsulated exception. 81 * 82 * @param msg the exception's detail message 83 * @param reason the encapsulated exception 84 */ 85 public OgnlException( String msg, Throwable reason ) 86 { 87 super( msg ); 88 this.reason = reason; 89 90 if ( initCause != null ) 91 { 92 try 93 { 94 initCause.invoke( this, reason ); 95 } 96 catch ( Exception ignored ) 97 { 98 /** ignore */ 99 } 100 } 101 } 102 103 /** 104 * Returns the encapsulated exception, or null if there is none. 105 * 106 * @return the encapsulated exception 107 */ 108 public Throwable getReason() 109 { 110 return reason; 111 } 112 113 /** 114 * Returns the Evaluation that was the root evaluation when the exception was thrown. 115 * 116 * @return The {@link Evaluation}. 117 */ 118 public Evaluation getEvaluation() 119 { 120 return evaluation; 121 } 122 123 /** 124 * Sets the Evaluation that was current when this exception was thrown. 125 * 126 * @param value The {@link Evaluation}. 127 */ 128 public void setEvaluation( Evaluation value ) 129 { 130 evaluation = value; 131 } 132 133 /** 134 * Returns a string representation of this exception. 135 * 136 * @return a string representation of this exception 137 */ 138 @Override 139 public String toString() 140 { 141 if ( reason == null ) 142 { 143 return super.toString(); 144 } 145 146 return super.toString() + " [" + reason + "]"; 147 } 148 149 /** 150 * Prints the stack trace for this (and possibly the encapsulated) exception on System.err. 151 */ 152 @Override 153 public void printStackTrace() 154 { 155 printStackTrace( System.err ); 156 } 157 158 /** 159 * Prints the stack trace for this (and possibly the encapsulated) exception on the given print stream. 160 */ 161 @Override 162 public void printStackTrace( java.io.PrintStream s ) 163 { 164 synchronized ( s ) 165 { 166 super.printStackTrace( s ); 167 if ( reason != null ) 168 { 169 s.println( "/-- Encapsulated exception ------------\\" ); 170 reason.printStackTrace( s ); 171 s.println( "\\--------------------------------------/" ); 172 } 173 } 174 } 175 176 /** 177 * Prints the stack trace for this (and possibly the encapsulated) exception on the given print writer. 178 */ 179 @Override 180 public void printStackTrace( java.io.PrintWriter s ) 181 { 182 synchronized ( s ) 183 { 184 super.printStackTrace( s ); 185 if ( reason != null ) 186 { 187 s.println( "/-- Encapsulated exception ------------\\" ); 188 reason.printStackTrace( s ); 189 s.println( "\\--------------------------------------/" ); 190 } 191 } 192 } 193 }