277 lines
9.7 KiB
C++
277 lines
9.7 KiB
C++
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* $Id: XMLException.hpp 673960 2008-07-04 08:50:12Z borisk $
|
|
*/
|
|
|
|
#if !defined(XERCESC_INCLUDE_GUARD_XMLEXCEPTION_HPP)
|
|
#define XERCESC_INCLUDE_GUARD_XMLEXCEPTION_HPP
|
|
|
|
#include <xercesc/util/XercesDefs.hpp>
|
|
#include <xercesc/util/XMemory.hpp>
|
|
#include <xercesc/util/XMLExceptMsgs.hpp>
|
|
#include <xercesc/util/XMLUni.hpp>
|
|
#include <xercesc/framework/XMLErrorReporter.hpp>
|
|
|
|
XERCES_CPP_NAMESPACE_BEGIN
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// This is the base class from which all the XML parser exceptions are
|
|
// derived. The virtual interface is very simple and most of the functionality
|
|
// is in this class.
|
|
//
|
|
// Because all derivatives are EXACTLY the same except for the static
|
|
// string that is used to hold the name of the class, a macro is provided
|
|
// below via which they are all created.
|
|
// ---------------------------------------------------------------------------
|
|
class XMLUTIL_EXPORT XMLException : public XMemory
|
|
{
|
|
public:
|
|
// -----------------------------------------------------------------------
|
|
// Virtual Destructor
|
|
// -----------------------------------------------------------------------
|
|
virtual ~XMLException();
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
// The XML exception virtual interface
|
|
// -----------------------------------------------------------------------
|
|
virtual const XMLCh* getType() const = 0;
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Getter methods
|
|
// -----------------------------------------------------------------------
|
|
XMLExcepts::Codes getCode() const;
|
|
const XMLCh* getMessage() const;
|
|
const char* getSrcFile() const;
|
|
XMLFileLoc getSrcLine() const;
|
|
XMLErrorReporter::ErrTypes getErrorType() const;
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Setter methods
|
|
// -----------------------------------------------------------------------
|
|
void setPosition(const char* const file, const XMLFileLoc line);
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Hidden constructors and operators
|
|
//
|
|
// NOTE: Technically, these should be protected, since this is a
|
|
// base class that is never used directly. However, VC++ 6.0 will
|
|
// fail to catch via a reference to base class if the ctors are
|
|
// not public!! This seems to have been caused by the install
|
|
// of IE 5.0.
|
|
// -----------------------------------------------------------------------
|
|
XMLException();
|
|
XMLException(const char* const srcFile, const XMLFileLoc srcLine, MemoryManager* const memoryManager = 0);
|
|
XMLException(const XMLException& toCopy);
|
|
XMLException& operator=(const XMLException& toAssign);
|
|
|
|
protected :
|
|
// -----------------------------------------------------------------------
|
|
// Protected methods
|
|
// -----------------------------------------------------------------------
|
|
void loadExceptText
|
|
(
|
|
const XMLExcepts::Codes toLoad
|
|
);
|
|
void loadExceptText
|
|
(
|
|
const XMLExcepts::Codes toLoad
|
|
, const XMLCh* const text1
|
|
, const XMLCh* const text2 = 0
|
|
, const XMLCh* const text3 = 0
|
|
, const XMLCh* const text4 = 0
|
|
);
|
|
void loadExceptText
|
|
(
|
|
const XMLExcepts::Codes toLoad
|
|
, const char* const text1
|
|
, const char* const text2 = 0
|
|
, const char* const text3 = 0
|
|
, const char* const text4 = 0
|
|
);
|
|
|
|
|
|
private :
|
|
// -----------------------------------------------------------------------
|
|
// Data members
|
|
//
|
|
// fCode
|
|
// The error code that this exception represents.
|
|
//
|
|
// fSrcFile
|
|
// fSrcLine
|
|
// These are the file and line information from the source where the
|
|
// exception was thrown from.
|
|
//
|
|
// fMsg
|
|
// The loaded message text for this exception.
|
|
// -----------------------------------------------------------------------
|
|
XMLExcepts::Codes fCode;
|
|
char* fSrcFile;
|
|
XMLFileLoc fSrcLine;
|
|
XMLCh* fMsg;
|
|
|
|
protected:
|
|
MemoryManager* fMemoryManager;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// XMLException: Getter methods
|
|
// ---------------------------------------------------------------------------
|
|
inline XMLExcepts::Codes XMLException::getCode() const
|
|
{
|
|
return fCode;
|
|
}
|
|
|
|
inline const XMLCh* XMLException::getMessage() const
|
|
{
|
|
return fMsg;
|
|
}
|
|
|
|
inline const char* XMLException::getSrcFile() const
|
|
{
|
|
if (!fSrcFile)
|
|
return "";
|
|
return fSrcFile;
|
|
}
|
|
|
|
inline XMLFileLoc XMLException::getSrcLine() const
|
|
{
|
|
return fSrcLine;
|
|
}
|
|
|
|
inline XMLErrorReporter::ErrTypes XMLException::getErrorType() const
|
|
{
|
|
if ((fCode >= XMLExcepts::W_LowBounds) && (fCode <= XMLExcepts::W_HighBounds))
|
|
return XMLErrorReporter::ErrType_Warning;
|
|
else if ((fCode >= XMLExcepts::F_LowBounds) && (fCode <= XMLExcepts::F_HighBounds))
|
|
return XMLErrorReporter::ErrType_Fatal;
|
|
else if ((fCode >= XMLExcepts::E_LowBounds) && (fCode <= XMLExcepts::E_HighBounds))
|
|
return XMLErrorReporter::ErrType_Error;
|
|
return XMLErrorReporter::ErrTypes_Unknown;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// This macro is used to create derived classes. They are all identical
|
|
// except the name of the exception, so it crazy to type them in over and
|
|
// over.
|
|
// ---------------------------------------------------------------------------
|
|
#define MakeXMLException(theType, expKeyword) \
|
|
class expKeyword theType : public XMLException \
|
|
{ \
|
|
public: \
|
|
\
|
|
theType(const char* const srcFile \
|
|
, const XMLFileLoc srcLine \
|
|
, const XMLExcepts::Codes toThrow \
|
|
, MemoryManager* memoryManager = 0) : \
|
|
XMLException(srcFile, srcLine, memoryManager) \
|
|
{ \
|
|
loadExceptText(toThrow); \
|
|
} \
|
|
\
|
|
theType(const theType& toCopy) : \
|
|
\
|
|
XMLException(toCopy) \
|
|
{ \
|
|
} \
|
|
\
|
|
theType(const char* const srcFile \
|
|
, const XMLFileLoc srcLine \
|
|
, const XMLExcepts::Codes toThrow \
|
|
, const XMLCh* const text1 \
|
|
, const XMLCh* const text2 = 0 \
|
|
, const XMLCh* const text3 = 0 \
|
|
, const XMLCh* const text4 = 0 \
|
|
, MemoryManager* memoryManager = 0) : \
|
|
XMLException(srcFile, srcLine, memoryManager) \
|
|
{ \
|
|
loadExceptText(toThrow, text1, text2, text3, text4); \
|
|
} \
|
|
\
|
|
theType(const char* const srcFile \
|
|
, const XMLFileLoc srcLine \
|
|
, const XMLExcepts::Codes toThrow \
|
|
, const char* const text1 \
|
|
, const char* const text2 = 0 \
|
|
, const char* const text3 = 0 \
|
|
, const char* const text4 = 0 \
|
|
, MemoryManager* memoryManager = 0) : \
|
|
XMLException(srcFile, srcLine, memoryManager) \
|
|
{ \
|
|
loadExceptText(toThrow, text1, text2, text3, text4); \
|
|
} \
|
|
\
|
|
virtual ~theType() {} \
|
|
\
|
|
theType& operator=(const theType& toAssign) \
|
|
{ \
|
|
XMLException::operator=(toAssign); \
|
|
return *this; \
|
|
} \
|
|
\
|
|
virtual XMLException* duplicate() const \
|
|
{ \
|
|
return new (fMemoryManager) theType(*this); \
|
|
} \
|
|
\
|
|
virtual const XMLCh* getType() const \
|
|
{ \
|
|
return XMLUni::fg##theType##_Name; \
|
|
} \
|
|
\
|
|
private : \
|
|
theType(); \
|
|
};
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// This macros is used to actually throw an exception. It is used in order
|
|
// to make sure that source code line/col info is stored correctly, and to
|
|
// give flexibility for other stuff in the future.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#define ThrowXML(type,code) throw type(__FILE__, __LINE__, code)
|
|
|
|
#define ThrowXML1(type,code,p1) throw type(__FILE__, __LINE__, code, p1)
|
|
|
|
#define ThrowXML2(type,code,p1,p2) throw type(__FILE__, __LINE__, code, p1, p2)
|
|
|
|
#define ThrowXML3(type,code,p1,p2,p3) throw type(__FILE__, __LINE__, code, p1, p2, p3)
|
|
|
|
#define ThrowXML4(type,code,p1,p2,p3,p4) throw type(__FILE__, __LINE__, code, p1, p2, p3, p4)
|
|
|
|
#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
|
|
|
|
#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
|
|
|
|
#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
|
|
|
|
#define ThrowXMLwithMemMgr3(type,code,p1,p2,p3,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, p3, 0, memMgr)
|
|
|
|
#define ThrowXMLwithMemMgr4(type,code,p1,p2,p3,p4,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, p3, p4, memMgr)
|
|
|
|
XERCES_CPP_NAMESPACE_END
|
|
|
|
#endif
|