XMLException.hpp Source File

00001 /*
00002  * The Apache Software License, Version 1.1

00003  * 

00004  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights

00005  * reserved.

00006  * 

00007  * Redistribution and use in source and binary forms, with or without

00008  * modification, are permitted provided that the following conditions

00009  * are met:

00010  * 

00011  * 1. Redistributions of source code must retain the above copyright

00012  *    notice, this list of conditions and the following disclaimer. 

00013  * 

00014  * 2. Redistributions in binary form must reproduce the above copyright

00015  *    notice, this list of conditions and the following disclaimer in

00016  *    the documentation and/or other materials provided with the

00017  *    distribution.

00018  * 

00019  * 3. The end-user documentation included with the redistribution,

00020  *    if any, must include the following acknowledgment:  

00021  *       "This product includes software developed by the

00022  *        Apache Software Foundation (http://www.apache.org/)."

00023  *    Alternately, this acknowledgment may appear in the software itself,

00024  *    if and wherever such third-party acknowledgments normally appear.

00025  * 

00026  * 4. The names "Xerces" and "Apache Software Foundation" must

00027  *    not be used to endorse or promote products derived from this

00028  *    software without prior written permission. For written 

00029  *    permission, please contact apache\@apache.org.

00030  * 

00031  * 5. Products derived from this software may not be called "Apache",

00032  *    nor may "Apache" appear in their name, without prior written

00033  *    permission of the Apache Software Foundation.

00034  * 

00035  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED

00036  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

00037  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

00038  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR

00039  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

00040  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

00041  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

00042  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

00043  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

00044  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

00045  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

00046  * SUCH DAMAGE.

00047  * ====================================================================

00048  * 

00049  * This software consists of voluntary contributions made by many

00050  * individuals on behalf of the Apache Software Foundation, and was

00051  * originally based on software copyright (c) 1999, International

00052  * Business Machines, Inc., http://www.ibm.com .  For more information

00053  * on the Apache Software Foundation, please see

00054  * <http://www.apache.org/>.

00055  */
00056 
00057 /*
00058  * $Id: XMLException.hpp,v 1.5 2000/05/04 02:43:45 aruna1 Exp $

00059  */
00060 
00061 #if !defined(EXCEPTION_HPP)
00062 #define EXCEPTION_HPP
00063 
00064 #include <util/XercesDefs.hpp>
00065 #include <util/XMLExceptMsgs.hpp>
00066 #include <util/XMLUni.hpp>
00067 
00068 
00069 // ---------------------------------------------------------------------------
00070 //  This is the base class from which all the XML parser exceptions are
00071 //  derived. The virtual interface is very simple and most of the functionality
00072 //  is in this class.
00073 //
00074 //  Because all derivatives are EXACTLY the same except for the static
00075 //  string that is used to hold the name of the class, a macro is provided
00076 //  below via which they are all created.
00077 // ---------------------------------------------------------------------------
00078 class  XMLException
00079 {
00080 public:
00081     // -----------------------------------------------------------------------
00082     //  Virtual Destructor
00083     // -----------------------------------------------------------------------
00084     virtual ~XMLException();
00085 
00086 
00087     // -----------------------------------------------------------------------
00088     //  The XML exception virtual interface
00089     // -----------------------------------------------------------------------
00090     virtual const XMLCh* getType() const = 0;
00091 
00092 
00093     // -----------------------------------------------------------------------
00094     //  Getter methods
00095     // -----------------------------------------------------------------------
00096     XMLExcepts::Codes getCode() const;
00097     const XMLCh* getMessage() const;
00098     const char* getSrcFile() const;
00099     unsigned int getSrcLine() const;
00100 
00101 
00102     // -----------------------------------------------------------------------
00103     //  Setter methods
00104     // -----------------------------------------------------------------------
00105     void setPosition(const char* const file, const unsigned int line);
00106 
00107 
00108     // -----------------------------------------------------------------------
00109     //  Hidden constructors and operators
00110     //
00111     //  NOTE:   Technically, these should be protected, since this is a
00112     //          base class that is never used directly. However, VC++ 6.0 will
00113     //          fail to catch via a reference to base class if the ctors are
00114     //          not public!! This seems to have been caused by the install
00115     //          of IE 5.0.
00116     // -----------------------------------------------------------------------
00117     XMLException();
00118     XMLException(const char* const srcFile, const unsigned int srcLine);
00119     XMLException(const XMLException& toCopy);
00120     void operator=(const XMLException& toAssign);
00121 
00122 
00123 protected :
00124     // -----------------------------------------------------------------------
00125     //  Protected methods
00126     // -----------------------------------------------------------------------
00127     void loadExceptText
00128     (
00129         const   XMLExcepts::Codes toLoad
00130     );
00131     void loadExceptText
00132     (
00133         const   XMLExcepts::Codes toLoad
00134         , const XMLCh* const        text1
00135         , const XMLCh* const        text2 = 0
00136         , const XMLCh* const        text3 = 0
00137         , const XMLCh* const        text4 = 0
00138     );
00139     void loadExceptText
00140     (
00141         const   XMLExcepts::Codes toLoad
00142         , const char* const         text1
00143         , const char* const         text2 = 0
00144         , const char* const         text3 = 0
00145         , const char* const         text4 = 0
00146     );
00147 
00148 
00149 private :
00150     // -----------------------------------------------------------------------
00151     //  Data members
00152     //
00153     //  fCode
00154     //      The error code that this exception represents.
00155     //
00156     //  fSrcFile
00157     //  fSrcLine
00158     //      These are the file and line information from the source where the
00159     //      exception was thrown from.
00160     //
00161     //  fMsg
00162     //      The loaded message text for this exception.
00163     // -----------------------------------------------------------------------
00164     XMLExcepts::Codes fCode;
00165     char*               fSrcFile;
00166     unsigned int        fSrcLine;
00167     XMLCh*              fMsg;
00168 };
00169 
00170 // ---------------------------------------------------------------------------
00171 //  XMLException: Getter methods
00172 // ---------------------------------------------------------------------------
00173 inline XMLExcepts::Codes XMLException::getCode() const

00174 {
00175     return fCode;
00176 }
00177 
00178 inline const XMLCh* XMLException::getMessage() const

00179 {
00180     return fMsg;
00181 }
00182 
00183 inline const char* XMLException::getSrcFile() const

00184 {
00185     if (!fSrcFile)
00186         return "";
00187     return fSrcFile;
00188 }
00189 
00190 inline unsigned int XMLException::getSrcLine() const

00191 {
00192     return fSrcLine;
00193 }
00194 
00195 
00196 // ---------------------------------------------------------------------------
00197 //  This macro is used to create derived classes. They are all identical
00198 //  except the name of the exception, so it crazy to type them in over and
00199 //  over.
00200 // ---------------------------------------------------------------------------
00201 #define MakeXMLException(theType, expKeyword) \

00202 class expKeyword theType : public XMLException \

00203 { \

00204 public: \

00205  \

00206     theType(const   char* const         srcFile \

00207             , const unsigned int        srcLine \

00208             , const XMLExcepts::Codes toThrow) : \

00209         XMLException(srcFile, srcLine) \

00210     { \

00211         loadExceptText(toThrow); \

00212     } \

00213  \

00214     theType(const theType& toCopy) : \

00215  \

00216         XMLException(toCopy) \

00217     { \

00218     } \

00219   \

00220     theType(const   char* const         srcFile \

00221             , const unsigned int        srcLine \

00222             , const XMLExcepts::Codes toThrow \

00223             , const XMLCh* const        text1 \

00224             , const XMLCh* const        text2 = 0 \

00225             , const XMLCh* const        text3 = 0 \

00226             , const XMLCh* const        text4 = 0) : \

00227         XMLException(srcFile, srcLine) \

00228     { \

00229         loadExceptText(toThrow, text1, text2, text3, text4); \

00230     } \

00231  \

00232     theType(const   char* const         srcFile \

00233             , const unsigned int        srcLine \

00234             , const XMLExcepts::Codes toThrow \

00235             , const char* const         text1 \

00236             , const char* const         text2 = 0 \

00237             , const char* const         text3 = 0 \

00238             , const char* const         text4 = 0) : \

00239         XMLException(srcFile, srcLine) \

00240     { \

00241         loadExceptText(toThrow, text1, text2, text3, text4); \

00242     } \

00243  \

00244     virtual ~theType() {} \

00245  \

00246     theType& operator=(const theType& toAssign) \

00247     { \

00248         XMLException::operator=(toAssign); \

00249         return *this; \

00250     } \

00251  \

00252     virtual XMLException* duplicate() const \

00253     { \

00254         return new theType(*this); \

00255     } \

00256  \

00257     virtual const XMLCh* getType() const \

00258     { \

00259         return XMLUni::fg##theType##_Name; \

00260     } \

00261  \

00262 private : \

00263     theType(); \

00264 };
00265 
00266 
00267 
00268 // ---------------------------------------------------------------------------
00269 //  This macros is used to actually throw an exception. It is used in order
00270 //  to make sure that source code line/col info is stored correctly, and to
00271 //  give flexibility for other stuff in the future.
00272 // ---------------------------------------------------------------------------
00273 #define ThrowXML(type,code) throw type(__FILE__, __LINE__, code)
00274 
00275 #define ThrowXML1(type,code,p1) throw type(__FILE__, __LINE__, code, p1)
00276 
00277 #define ThrowXML2(type,code,p1,p2) throw type(__FILE__, __LINE__, code, p1, p2)
00278 
00279 #define ThrowXML3(type,code,p1,p2,p3) throw type(__FILE__, __LINE__, code, p1, p2, p3)
00280 
00281 #define ThrowXML4(type,code,p1,p2,p3,p4) throw type(__FILE__, __LINE__, code, p1, p2, p3, p4)
00282 
00283 #endif