View Javadoc
1   /*
2    * reserved comment block
3    * DO NOT REMOVE OR ALTER!
4    */
5   /*
6    * Copyright 2001-2004 The Apache Software Foundation.
7    *
8    * Licensed under the Apache License, Version 2.0 (the "License");
9    * you may not use this file except in compliance with the License.
10   * 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, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  
21  package com.sun.org.apache.xerces.internal.util;
22  
23  import com.sun.org.apache.xerces.internal.xni.XMLLocator;
24  import com.sun.org.apache.xerces.internal.xni.XNIException;
25  import com.sun.org.apache.xerces.internal.xni.parser.XMLErrorHandler;
26  import com.sun.org.apache.xerces.internal.xni.parser.XMLParseException;
27  import org.xml.sax.ErrorHandler;
28  import org.xml.sax.SAXException;
29  import org.xml.sax.SAXParseException;
30  
31  /**
32   * This class wraps a SAX error handler in an XNI error handler.
33   *
34   * @see ErrorHandler
35   *
36   * @author Andy Clark, IBM
37   *
38   */
39  public class ErrorHandlerWrapper
40      implements XMLErrorHandler {
41  
42      //
43      // Data
44      //
45  
46      /** The SAX error handler. */
47      protected ErrorHandler fErrorHandler;
48  
49      //
50      // Constructors
51      //
52  
53      /** Default constructor. */
54      public ErrorHandlerWrapper() {}
55  
56      /** Wraps the specified SAX error handler. */
57      public ErrorHandlerWrapper(ErrorHandler errorHandler) {
58          setErrorHandler(errorHandler);
59      } // <init>(ErrorHandler)
60  
61      //
62      // Public methods
63      //
64  
65      /** Sets the SAX error handler. */
66      public void setErrorHandler(ErrorHandler errorHandler) {
67          fErrorHandler = errorHandler;
68      } // setErrorHandler(ErrorHandler)
69  
70      /** Returns the SAX error handler. */
71      public ErrorHandler getErrorHandler() {
72          return fErrorHandler;
73      } // getErrorHandler():ErrorHandler
74  
75      //
76      // XMLErrorHandler methods
77      //
78  
79      /**
80       * Reports a warning. Warnings are non-fatal and can be safely ignored
81       * by most applications.
82       *
83       * @param domain    The domain of the warning. The domain can be any
84       *                  string but is suggested to be a valid URI. The
85       *                  domain can be used to conveniently specify a web
86       *                  site location of the relevent specification or
87       *                  document pertaining to this warning.
88       * @param key       The warning key. This key can be any string and
89       *                  is implementation dependent.
90       * @param exception Exception.
91       *
92       * @throws XNIException Thrown to signal that the parser should stop
93       *                      parsing the document.
94       */
95      public void warning(String domain, String key,
96                          XMLParseException exception) throws XNIException {
97  
98          if (fErrorHandler != null) {
99                  SAXParseException saxException = createSAXParseException(exception);
100 
101                 try {
102                         fErrorHandler.warning(saxException);
103                 }
104                 catch (SAXParseException e) {
105                         throw createXMLParseException(e);
106                 }
107                 catch (SAXException e) {
108                         throw createXNIException(e);
109                 }
110         }
111 
112     } // warning(String,String,XMLParseException)
113 
114     /**
115      * Reports an error. Errors are non-fatal and usually signify that the
116      * document is invalid with respect to its grammar(s).
117      *
118      * @param domain    The domain of the error. The domain can be any
119      *                  string but is suggested to be a valid URI. The
120      *                  domain can be used to conveniently specify a web
121      *                  site location of the relevent specification or
122      *                  document pertaining to this error.
123      * @param key       The error key. This key can be any string and
124      *                  is implementation dependent.
125      * @param exception Exception.
126      *
127      * @throws XNIException Thrown to signal that the parser should stop
128      *                      parsing the document.
129      */
130     public void error(String domain, String key,
131                       XMLParseException exception) throws XNIException {
132 
133         if (fErrorHandler != null) {
134                 SAXParseException saxException = createSAXParseException(exception);
135 
136                 try {
137                         fErrorHandler.error(saxException);
138                 }
139                 catch (SAXParseException e) {
140                         throw createXMLParseException(e);
141                 }
142                 catch (SAXException e) {
143                         throw createXNIException(e);
144                 }
145         }
146 
147     } // error(String,String,XMLParseException)
148 
149     /**
150      * Report a fatal error. Fatal errors usually occur when the document
151      * is not well-formed and signifies that the parser cannot continue
152      * normal operation.
153      * <p>
154      * <strong>Note:</strong> The error handler should <em>always</em>
155      * throw an <code>XNIException</code> from this method. This exception
156      * can either be the same exception that is passed as a parameter to
157      * the method or a new XNI exception object. If the registered error
158      * handler fails to throw an exception, the continuing operation of
159      * the parser is undetermined.
160      *
161      * @param domain    The domain of the fatal error. The domain can be
162      *                  any string but is suggested to be a valid URI. The
163      *                  domain can be used to conveniently specify a web
164      *                  site location of the relevent specification or
165      *                  document pertaining to this fatal error.
166      * @param key       The fatal error key. This key can be any string
167      *                  and is implementation dependent.
168      * @param exception Exception.
169      *
170      * @throws XNIException Thrown to signal that the parser should stop
171      *                      parsing the document.
172      */
173     public void fatalError(String domain, String key,
174                            XMLParseException exception) throws XNIException {
175 
176         if (fErrorHandler != null) {
177                 SAXParseException saxException = createSAXParseException(exception);
178 
179                 try {
180                         fErrorHandler.fatalError(saxException);
181                 }
182                 catch (SAXParseException e) {
183                         throw createXMLParseException(e);
184                 }
185                 catch (SAXException e) {
186                         throw createXNIException(e);
187                 }
188         }
189 
190     } // fatalError(String,String,XMLParseException)
191 
192     //
193     // Protected methods
194     //
195 
196     /** Creates a SAXParseException from an XMLParseException. */
197     protected static SAXParseException createSAXParseException(XMLParseException exception) {
198         return new SAXParseException(exception.getMessage(),
199                                      exception.getPublicId(),
200                                      exception.getExpandedSystemId(),
201                                      exception.getLineNumber(),
202                                      exception.getColumnNumber(),
203                                      exception.getException());
204     } // createSAXParseException(XMLParseException):SAXParseException
205 
206     /** Creates an XMLParseException from a SAXParseException. */
207     protected static XMLParseException createXMLParseException(SAXParseException exception) {
208         final String fPublicId = exception.getPublicId();
209         final String fExpandedSystemId = exception.getSystemId();
210         final int fLineNumber = exception.getLineNumber();
211         final int fColumnNumber = exception.getColumnNumber();
212         XMLLocator location = new XMLLocator() {
213             public String getPublicId() { return fPublicId; }
214             public String getExpandedSystemId() { return fExpandedSystemId; }
215             public String getBaseSystemId() { return null; }
216             public String getLiteralSystemId() { return null; }
217             public int getColumnNumber() { return fColumnNumber; }
218             public int getLineNumber() { return fLineNumber; }
219             public int getCharacterOffset() { return -1; }
220             public String getEncoding() { return null; }
221             public String getXMLVersion() { return null; }
222         };
223         return new XMLParseException(location, exception.getMessage(),exception);
224     } // createXMLParseException(SAXParseException):XMLParseException
225 
226     /** Creates an XNIException from a SAXException.
227         NOTE:  care should be taken *not* to call this with a SAXParseException; this will
228         lose information!!! */
229     protected static XNIException createXNIException(SAXException exception) {
230         return new XNIException(exception.getMessage(),exception);
231     } // createXNIException(SAXException):XMLParseException
232 } // class ErrorHandlerWrapper