xercesc/sax/SAXException.hpp

0001 /*
0002  * Licensed to the Apache Software Foundation (ASF) under one or more
0003  * contributor license agreements.  See the NOTICE file distributed with
0004  * this work for additional information regarding copyright ownership.
0005  * The ASF licenses this file to You under the Apache License, Version 2.0
0006  * (the "License"); you may not use this file except in compliance with
0007  * the License.  You may obtain a copy of the License at
0008  *
0009  *      http://www.apache.org/licenses/LICENSE-2.0
0010  *
0011  * Unless required by applicable law or agreed to in writing, software
0012  * distributed under the License is distributed on an "AS IS" BASIS,
0013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014  * See the License for the specific language governing permissions and
0015  * limitations under the License.
0016  */
0017
0018 /*
0019  * $Id$
0020  */
0021
0022 #if !defined(XERCESC_INCLUDE_GUARD_SAXEXCEPTION_HPP)
0023 #define XERCESC_INCLUDE_GUARD_SAXEXCEPTION_HPP
0024
0025 #include <xercesc/util/XMLString.hpp>
0026 #include <xercesc/util/XMLUni.hpp>
0027 #include <xercesc/util/XMemory.hpp>
0028
0029 XERCES_CPP_NAMESPACE_BEGIN
0030
0031
0032 /**
0033   * Encapsulate a general SAX error or warning.
0034   *
0035   * <p>This class can contain basic error or warning information from
0036   * either the XML SAX parser or the application: a parser writer or
0037   * application writer can subclass it to provide additional
0038   * functionality.  SAX handlers may throw this exception or
0039   * any exception subclassed from it.</p>
0040   *
0041   * <p>If the application needs to pass through other types of
0042   * exceptions, it must wrap those exceptions in a SAXException
0043   * or an exception derived from a SAXException.</p>
0044   *
0045   * <p>If the parser or application needs to include information
0046   * about a specific location in an XML document, it should use the
0047   * SAXParseException subclass.</p>
0048   *
0049   * @see SAXParseException#SAXParseException
0050   */
0051 class SAX_EXPORT SAXException : public XMemory
0052 {
0053 public:
0054     /** @name Constructors and Destructor */
0055     //@{
0056     /** Default constructor
0057      * @param manager    Pointer to the memory manager to be used to
0058      *                   allocate objects.
0059      */
0060     SAXException(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) :
0061
0062         fMsg(XMLString::replicate(XMLUni::fgZeroLenString, manager))
0063         , fMemoryManager(manager)
0064     {
0065     }
0066
0067   /**
0068     * Create a new SAXException.
0069     *
0070     * @param msg The error or warning message.
0071     * @param manager    Pointer to the memory manager to be used to
0072     *                   allocate objects.
0073     */
0074     SAXException(const XMLCh* const msg,
0075                  MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) :
0076
0077         fMsg(XMLString::replicate(msg, manager))
0078         , fMemoryManager(manager)
0079     {
0080     }
0081
0082   /**
0083     * Create a new SAXException.
0084     *
0085     * @param msg The error or warning message.
0086     * @param manager    Pointer to the memory manager to be used to
0087     *                   allocate objects.
0088     */
0089     SAXException(const char* const msg,
0090                  MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) :
0091
0092         fMsg(XMLString::transcode(msg, manager))
0093         , fMemoryManager(manager)
0094     {
0095     }
0096
0097   /**
0098     * Copy constructor
0099     *
0100     * @param toCopy The exception to be copy constructed
0101     */
0102     SAXException(const SAXException& toCopy) :
0103         XMemory(toCopy)
0104         , fMsg(XMLString::replicate(toCopy.fMsg, toCopy.fMemoryManager))
0105         , fMemoryManager(toCopy.fMemoryManager)
0106     {
0107     }
0108
0109     /** Destructor */
0110     virtual ~SAXException()
0111     {
0112         fMemoryManager->deallocate(fMsg);//delete [] fMsg;
0113     }
0114
0115     //@}
0116
0117
0118     /** @name Public Operators */
0119     //@{
0120     /**
0121       * Assignment operator
0122       *
0123       * @param toCopy The object to be copied
0124       */
0125     SAXException& operator=(const SAXException& toCopy)
0126     {
0127         if (this == &toCopy)
0128             return *this;
0129
0130         fMemoryManager->deallocate(fMsg);//delete [] fMsg;
0131         fMsg = XMLString::replicate(toCopy.fMsg, toCopy.fMemoryManager);
0132         fMemoryManager = toCopy.fMemoryManager;
0133         return *this;
0134     }
0135     //@}
0136
0137     /** @name Getter Methods */
0138     //@{
0139     /**
0140       * Get the contents of the message
0141       *
0142       */
0143     virtual const XMLCh* getMessage() const
0144     {
0145         return fMsg;
0146     }
0147     //@}
0148
0149
0150 protected :
0151     // -----------------------------------------------------------------------
0152     //  Protected data members
0153     //
0154     //  fMsg
0155     //      This is the text of the error that is being thrown.
0156     // -----------------------------------------------------------------------
0157     XMLCh*  fMsg;
0158     MemoryManager* fMemoryManager;
0159 };
0160
0161 class SAX_EXPORT SAXNotSupportedException : public SAXException
0162 {
0163
0164 public:
0165     SAXNotSupportedException(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
0166
0167   /**
0168     * Create a new SAXException.
0169     *
0170     * @param msg The error or warning message.
0171     * @param manager    Pointer to the memory manager to be used to
0172     *                   allocate objects.
0173     */
0174     SAXNotSupportedException(const XMLCh* const msg,
0175                              MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
0176
0177   /**
0178     * Create a new SAXException.
0179     *
0180     * @param msg The error or warning message.
0181     * @param manager    Pointer to the memory manager to be used to
0182     *                   allocate objects.
0183     */
0184     SAXNotSupportedException(const char* const msg,
0185                              MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
0186
0187   /**
0188     * Copy constructor
0189     *
0190     * @param toCopy The exception to be copy constructed
0191     */
0192     SAXNotSupportedException(const SAXException& toCopy);
0193 };
0194
0195 class SAX_EXPORT SAXNotRecognizedException : public SAXException
0196 {
0197 public:
0198     SAXNotRecognizedException(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
0199
0200   /**
0201     * Create a new SAXException.
0202     *
0203     * @param msg The error or warning message.
0204     * @param manager    Pointer to the memory manager to be used to
0205     *                   allocate objects.
0206     */
0207     SAXNotRecognizedException(const XMLCh* const msg,
0208                               MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
0209
0210   /**
0211     * Create a new SAXException.
0212     *
0213     * @param msg The error or warning message.
0214     * @param manager    Pointer to the memory manager to be used to
0215     *                   allocate objects.
0216     */
0217     SAXNotRecognizedException(const char* const msg,
0218                               MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
0219
0220   /**
0221     * Copy constructor
0222     *
0223     * @param toCopy The exception to be copy constructed
0224     */
0225     SAXNotRecognizedException(const SAXException& toCopy);
0226 };
0227
0228 XERCES_CPP_NAMESPACE_END
0229
0230 #endif