001: /*
002:
003: Licensed to the Apache Software Foundation (ASF) under one or more
004: contributor license agreements. See the NOTICE file distributed with
005: this work for additional information regarding copyright ownership.
006: The ASF licenses this file to You under the Apache License, Version 2.0
007: (the "License"); you may not use this file except in compliance with
008: the License. You may obtain a copy of the License at
009:
010: http://www.apache.org/licenses/LICENSE-2.0
011:
012: Unless required by applicable law or agreed to in writing, software
013: distributed under the License is distributed on an "AS IS" BASIS,
014: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015: See the License for the specific language governing permissions and
016: limitations under the License.
017:
018: */
019: package org.apache.batik.xml;
020:
021: /**
022: * This class encapsulates a general XML error or warning.
023: *
024: * <p>This class can contain basic error or warning information from
025: * either the parser or the application.
026: *
027: * <p>If the application needs to pass through other types of
028: * exceptions, it must wrap those exceptions in a XMLException.
029: *
030: * @author <a href="mailto:stephane@hillion.org">Stephane Hillion</a>
031: * @version $Id: XMLException.java 475685 2006-11-16 11:16:05Z cam $
032: */
033: public class XMLException extends RuntimeException {
034:
035: /**
036: * @serial The embedded exception if tunnelling, or null.
037: */
038: protected Exception exception;
039:
040: /**
041: * Creates a new XMLException.
042: * @param message The error or warning message.
043: */
044: public XMLException(String message) {
045: super (message);
046: exception = null;
047: }
048:
049: /**
050: * Creates a new XMLException wrapping an existing exception.
051: *
052: * <p>The existing exception will be embedded in the new
053: * one, and its message will become the default message for
054: * the XMLException.
055: * @param e The exception to be wrapped in a XMLException.
056: */
057: public XMLException(Exception e) {
058: exception = e;
059: }
060:
061: /**
062: * Creates a new XMLException from an existing exception.
063: *
064: * <p>The existing exception will be embedded in the new
065: * one, but the new exception will have its own message.
066: * @param message The detail message.
067: * @param e The exception to be wrapped in a SAXException.
068: */
069: public XMLException(String message, Exception e) {
070: super (message);
071: exception = e;
072: }
073:
074: /**
075: * Return a detail message for this exception.
076: *
077: * <p>If there is a embedded exception, and if the XMLException
078: * has no detail message of its own, this method will return
079: * the detail message from the embedded exception.
080: * @return The error or warning message.
081: */
082: public String getMessage() {
083: String message = super .getMessage();
084:
085: if (message == null && exception != null) {
086: return exception.getMessage();
087: } else {
088: return message;
089: }
090: }
091:
092: /**
093: * Return the embedded exception, if any.
094: * @return The embedded exception, or null if there is none.
095: */
096: public Exception getException() {
097: return exception;
098: }
099:
100: /**
101: * Prints this <code>Exception</code> and its backtrace to the
102: * standard error stream.
103: */
104: public void printStackTrace() {
105: if (exception == null) {
106: super .printStackTrace();
107: } else {
108: synchronized (System.err) {
109: System.err.println(this );
110: super .printStackTrace();
111: }
112: }
113: }
114:
115: /**
116: * Prints this <code>Exception</code> and its backtrace to the
117: * specified print stream.
118: *
119: * @param s <code>PrintStream</code> to use for output
120: */
121: public void printStackTrace(java.io.PrintStream s) {
122: if (exception == null) {
123: super .printStackTrace(s);
124: } else {
125: synchronized (s) {
126: s.println(this );
127: super .printStackTrace();
128: }
129: }
130: }
131:
132: /**
133: * Prints this <code>Exception</code> and its backtrace to the specified
134: * print writer.
135: *
136: * @param s <code>PrintWriter</code> to use for output
137: */
138: public void printStackTrace(java.io.PrintWriter s) {
139: if (exception == null) {
140: super.printStackTrace(s);
141: } else {
142: synchronized (s) {
143: s.println(this);
144: super.printStackTrace(s);
145: }
146: }
147: }
148: }
|