diff --git a/src/xercesc/util/Transcoders/Cygwin/CygwinTransService.cpp b/src/xercesc/util/Transcoders/Cygwin/CygwinTransService.cpp
index f56d9bd60ff2f44026fb441c58af39d92e65e879..bc40178da3041a4e8acf13e85f30d0982dc56352 100644
--- a/src/xercesc/util/Transcoders/Cygwin/CygwinTransService.cpp
+++ b/src/xercesc/util/Transcoders/Cygwin/CygwinTransService.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:47:02 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2003/03/09 17:02:20 peiyongz
* PanicHandler
*
@@ -672,9 +675,10 @@ bool CygwinTransService::isAlias(const HKEY encodingKey
XMLTranscoder*
-CygwinTransService::makeNewXMLTranscoder(const XMLCh* const encodingName
+CygwinTransService::makeNewXMLTranscoder(const XMLCh* const encodingName
, XMLTransService::Codes& resValue
- , const unsigned int blockSize)
+ , const unsigned int blockSize
+ , MemoryManager* const manager)
{
const unsigned int upLen = 1024;
XMLCh upEncoding[upLen + 1];
@@ -703,7 +707,7 @@ CygwinTransService::makeNewXMLTranscoder(const XMLCh* const encodin
}
// We found it, so return a Cygwin transcoder for this encoding
- return new CygwinTranscoder
+ return new (manager) CygwinTranscoder
(
encodingName
, theEntry->getWinCP()
@@ -1024,6 +1028,36 @@ char* CygwinLCPTranscoder::transcode(const XMLCh* const toTranscode)
return retVal;
}
+char* CygwinLCPTranscoder::transcode(const XMLCh* const toTranscode
+ MemoryManager* const manager)
+{
+ if (!toTranscode)
+ return 0;
+
+ char* retVal = 0;
+ if (*toTranscode)
+ {
+ // Calc the needed size
+ const unsigned int neededLen = ::WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)toTranscode, -1, NULL, 0, NULL, NULL);
+ if (neededLen == (unsigned int)-1)
+ return 0;
+
+ // Allocate a buffer of that size plus one for the null and transcode
+ // Returned length of WideCharToMultiByte includes terminating NUL.
+ retVal = (char*) manager->allocate((neededLen+1) * sizeof(char)); //new char[neededLen+1];
+ ::WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)toTranscode, -1, retVal, neededLen+1, NULL, NULL);
+
+ // And cap it off anyway just to make sure
+ retVal[neededLen] = 0;
+ }
+ else
+ {
+ retVal = (char*) manager->allocate(sizeof(char)); //new char[1];
+ retVal[0] = 0;
+ }
+ return retVal;
+}
+
XMLCh* CygwinLCPTranscoder::transcode(const char* const toTranscode)
{
@@ -1053,6 +1087,35 @@ XMLCh* CygwinLCPTranscoder::transcode(const char* const toTranscode)
return retVal;
}
+XMLCh* CygwinLCPTranscoder::transcode(const char* const toTranscode,
+ MemoryManager* const manager)
+{
+ if (!toTranscode)
+ return 0;
+
+ XMLCh* retVal = 0;
+ if (*toTranscode)
+ {
+ // Calculate the buffer size required
+ const unsigned int neededLen = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, toTranscode, -1, NULL, 0);
+ if (neededLen == (unsigned int)-1)
+ return 0;
+
+ // Allocate a buffer of that size plus one for the null and transcode
+ retVal = (XMLCh*) manager->allocate((neededLen + 1) * sizeof(XMLCh)); //new XMLCh[neededLen + 1];
+ ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, toTranscode, -1, (LPWSTR)retVal, neededLen + 1);
+
+ // Cap it off just to make sure. We are so paranoid!
+ retVal[neededLen] = 0;
+ }
+ else
+ {
+ retVal = (XMLCh*) manager->allocate(sizeof(XMLCh)); //new XMLCh[1];
+ retVal[0] = 0;
+ }
+ return retVal;
+}
+
bool CygwinLCPTranscoder::transcode( const char* const toTranscode
, XMLCh* const toFill
diff --git a/src/xercesc/util/Transcoders/Cygwin/CygwinTransService.hpp b/src/xercesc/util/Transcoders/Cygwin/CygwinTransService.hpp
index 5fd6d567306e7e3e6be696739094fa7c243d1398..36535b23dedc8732d38ddcf36dc5729cc355bdd4 100644
--- a/src/xercesc/util/Transcoders/Cygwin/CygwinTransService.hpp
+++ b/src/xercesc/util/Transcoders/Cygwin/CygwinTransService.hpp
@@ -120,6 +120,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
virtual int auxCompareString
@@ -259,8 +260,12 @@ public :
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/ICU/ICUTransService.cpp b/src/xercesc/util/Transcoders/ICU/ICUTransService.cpp
index c7b380e8fa3bbb743c73d36308ced0528912b207..28d582a2cb09df7bab12e9a7e2d997041a224476 100644
--- a/src/xercesc/util/Transcoders/ICU/ICUTransService.cpp
+++ b/src/xercesc/util/Transcoders/ICU/ICUTransService.cpp
@@ -332,7 +332,8 @@ void ICUTransService::lowerCase(XMLCh* const toLowerCase) const
XMLTranscoder* ICUTransService::
makeNewXMLTranscoder(const XMLCh* const encodingName
, XMLTransService::Codes& resValue
- , const unsigned int blockSize)
+ , const unsigned int blockSize
+ , MemoryManager* const manager)
{
//
// If UChar and XMLCh are not the same size, then we have premassage the
@@ -360,7 +361,7 @@ makeNewXMLTranscoder(const XMLCh* const encodingName
return 0;
}
- return new ICUTranscoder(encodingName, converter, blockSize);
+ return new (manager) ICUTranscoder(encodingName, converter, blockSize);
}
diff --git a/src/xercesc/util/Transcoders/ICU/ICUTransService.hpp b/src/xercesc/util/Transcoders/ICU/ICUTransService.hpp
index caad7771ede0306a766bce4203b4a103b5a1ef82..a56ad59feb8b0e69a16a639e8c185e5d191eeac1 100644
--- a/src/xercesc/util/Transcoders/ICU/ICUTransService.hpp
+++ b/src/xercesc/util/Transcoders/ICU/ICUTransService.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2003/05/15 18:47:03 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.6 2003/03/07 18:15:57 tng
* Return a reference instead of void for operator=
*
@@ -172,6 +175,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
@@ -280,8 +284,12 @@ public :
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/Iconv/IconvTransService.cpp b/src/xercesc/util/Transcoders/Iconv/IconvTransService.cpp
index d70f03f1302edfcd7d22ff20cda694d125adeeaf..07828f185666b0c69db16a3b0175bcb4f113a196 100644
--- a/src/xercesc/util/Transcoders/Iconv/IconvTransService.cpp
+++ b/src/xercesc/util/Transcoders/Iconv/IconvTransService.cpp
@@ -62,10 +62,12 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
+#include "IconvTransService.hpp"
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/XMLUni.hpp>
-#include "IconvTransService.hpp"
+#include <xercesc/framework/MemoryManager.hpp>
#include <wchar.h>
+
#if defined (XML_GCC) || defined (XML_PTX) || defined (XML_IBMVAOS2)
#if defined(XML_BEOS)
wint_t towlower(wint_t wc) {
@@ -214,7 +216,8 @@ bool IconvTransService::supportsSrcOfs() const
XMLTranscoder*
IconvTransService::makeNewXMLTranscoder(const XMLCh* const encodingName
, XMLTransService::Codes& resValue
- , const unsigned int )
+ , const unsigned int
+ , MemoryManager* const)
{
//
// NOTE: We don't use the block size here
@@ -347,6 +350,58 @@ char* IconvLCPTranscoder::transcode(const XMLCh* const toTranscode)
return retVal;
}
+char* IconvLCPTranscoder::transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager)
+{
+ if (!toTranscode)
+ return 0;
+
+ char* retVal = 0;
+ if (*toTranscode)
+ {
+ unsigned int wLent = getWideCharLength(toTranscode);
+
+ wchar_t tmpWideCharArr[gTempBuffArraySize];
+ wchar_t* allocatedArray = 0;
+ wchar_t* wideCharBuf = 0;
+
+ if (wLent >= gTempBuffArraySize)
+ wideCharBuf = allocatedArray = (wchar_t*) manager->allocate
+ (
+ (wLent + 1) * sizeof(wchar_t)
+ );//new wchar_t[wLent + 1];
+ else
+ wideCharBuf = tmpWideCharArr;
+
+ for (unsigned int i = 0; i < wLent; i++)
+ {
+ wideCharBuf[i] = toTranscode[i];
+ }
+ wideCharBuf[wLent] = 0x00;
+
+ // Calc the needed size.
+ const size_t neededLen = ::wcstombs(NULL, wideCharBuf, 0);
+ if (neededLen == -1)
+ {
+ manager->deallocate(allocatedArray);//delete [] allocatedArray;
+ retVal = (char*) manager->allocate(sizeof(char)); //new char[1];
+ retVal[0] = 0;
+ return retVal;
+ }
+
+ retVal = (char*) manager->allocate((neededLen + 1) * sizeof(char));//new char[neededLen + 1];
+ ::wcstombs(retVal, wideCharBuf, neededLen);
+ retVal[neededLen] = 0;
+ manager->deallocate(allocatedArray);//delete [] allocatedArray;
+ }
+ else
+ {
+ retVal = (char*) manager->allocate(sizeof(char));//new char[1];
+ retVal[0] = 0;
+ }
+ return retVal;
+}
+
bool IconvLCPTranscoder::transcode( const XMLCh* const toTranscode
, char* const toFill
@@ -443,6 +498,52 @@ XMLCh* IconvLCPTranscoder::transcode(const char* const toTranscode)
return retVal;
}
+XMLCh* IconvLCPTranscoder::transcode(const char* const toTranscode,
+ MemoryManager* const manager)
+{
+ if (!toTranscode)
+ return 0;
+
+ XMLCh* retVal = 0;
+ if (*toTranscode)
+ {
+ const unsigned int len = calcRequiredSize(toTranscode);
+ if (len == 0)
+ {
+ retVal = (XMLCh*) manager->allocate(sizeof(XMLCh)); //new XMLCh[1];
+ retVal[0] = 0;
+ return retVal;
+ }
+
+ wchar_t tmpWideCharArr[gTempBuffArraySize];
+ wchar_t* allocatedArray = 0;
+ wchar_t* wideCharBuf = 0;
+
+ if (len >= gTempBuffArraySize)
+ wideCharBuf = allocatedArray = (wchar_t*) manager->allocate
+ (
+ (len + 1) * sizeof(wchar_t)
+ );//new wchar_t[len + 1];
+ else
+ wideCharBuf = tmpWideCharArr;
+
+ ::mbstowcs(wideCharBuf, toTranscode, len);
+ retVal = (XMLCh*) manager->allocate((len + 1) *sizeof(XMLCh));//new XMLCh[len + 1];
+ for (unsigned int i = 0; i < len; i++)
+ {
+ retVal[i] = (XMLCh) wideCharBuf[i];
+ }
+ retVal[len] = 0x00;
+ manager->deallocate(allocatedArray);//delete [] allocatedArray;
+ }
+ else
+ {
+ retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
+ retVal[0] = 0;
+ }
+ return retVal;
+}
+
bool IconvLCPTranscoder::transcode( const char* const toTranscode
, XMLCh* const toFill
diff --git a/src/xercesc/util/Transcoders/Iconv/IconvTransService.hpp b/src/xercesc/util/Transcoders/Iconv/IconvTransService.hpp
index 1b7f71809e493d9dd63ebeb18e09ec59bf66d085..728a4c3d01b980eddfc49ccfca9d660d97bd3333 100644
--- a/src/xercesc/util/Transcoders/Iconv/IconvTransService.hpp
+++ b/src/xercesc/util/Transcoders/Iconv/IconvTransService.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:47:03 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2003/03/07 18:15:57 tng
* Return a reference instead of void for operator=
*
@@ -157,6 +160,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
@@ -187,6 +191,8 @@ public :
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
@@ -196,6 +202,8 @@ public :
);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/Iconv390/Iconv390TransService.cpp b/src/xercesc/util/Transcoders/Iconv390/Iconv390TransService.cpp
index c454678314ef931181fbbcf33db15b19c75260c5..5ee01923afef319273eccb931dbc733b86379712 100644
--- a/src/xercesc/util/Transcoders/Iconv390/Iconv390TransService.cpp
+++ b/src/xercesc/util/Transcoders/Iconv390/Iconv390TransService.cpp
@@ -62,10 +62,11 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
+#include "Iconv390TransService.hpp"
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/util/regx/XMLUniCharacter.hpp>
-#include "Iconv390TransService.hpp"
+#include <xercesc/framework/MemoryManager.hpp>
#include <wchar.h>
#include <string.h>
@@ -316,7 +317,8 @@ bool Iconv390TransService::supportsSrcOfs() const
XMLTranscoder*
Iconv390TransService::makeNewXMLTranscoder(const XMLCh* const encodingName
, XMLTransService::Codes& resValue
- , const unsigned int )
+ , const unsigned int
+ , MemoryManager* const)
{
// This is a minimalist transcoding service, that only supports a local
// default transcoder. All named encodings return zero as a failure,
@@ -425,6 +427,36 @@ char* Iconv390LCPTranscoder::transcode(const XMLCh* const toTranscode)
return retVal;
}
+char* Iconv390LCPTranscoder::transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager)
+{
+ if (!toTranscode)
+ return 0;
+
+ char* retVal = 0;
+ if (*toTranscode)
+ {
+ unsigned int wLent = getWideCharLength(toTranscode);
+ //
+ // Translate the input from Unicode XMLCh format into
+ // ibm-037 char format via the lookup table.
+ //
+ retVal = (char*) manager->allocate((wLent + 1) * sizeof(char));//new char[wLent + 1];
+ const XMLCh *srcPtr = toTranscode;
+ char *outPtr = retVal;
+
+ while (*srcPtr != 0)
+ *outPtr++ = gUnicodeToIBM037XlatTable[*srcPtr++];
+ *outPtr=0;
+ }
+ else
+ {
+ retVal = (char*) manager->allocate(sizeof(char));//new char[1];
+ retVal[0] = 0;
+ }
+ return retVal;
+}
+
bool Iconv390LCPTranscoder::transcode( const XMLCh* const toTranscode
, char* const toFill
@@ -503,6 +535,53 @@ XMLCh* Iconv390LCPTranscoder::transcode(const char* const toTranscode)
return retVal;
}
+XMLCh* Iconv390LCPTranscoder::transcode(const char* const toTranscode,
+ MemoryManager* const manager)
+{
+ if (!toTranscode)
+ return 0;
+
+ XMLCh* retVal = 0;
+ if (*toTranscode)
+ {
+ const unsigned int len = calcRequiredSize(toTranscode);
+ if (len == 0)
+ {
+ retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
+ retVal[0] = 0;
+ return retVal;
+ }
+
+ wchar_t tmpWideCharArr[gTempBuffArraySize];
+ wchar_t* allocatedArray = 0;
+ wchar_t* wideCharBuf = 0;
+
+ retVal = (XMLCh*) manager->allocate((len + 1) * sizeof(XMLCh));//new XMLCh[len + 1];
+
+ size_t retCode;
+ char *tmpInPtr = (char*) toTranscode;
+ char *tmpOutPtr = (char*) retVal;
+ size_t inByteLeft = len;
+ size_t outByteLeft = len*2;
+ {
+ XMLMutexLock lockConverter(&converter->fMutex);
+ retCode = iconv(converter->fIconv390Descriptor, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
+ }
+ if (retCode == -1) {
+ delete [] retVal;
+ return 0;
+ }
+ retVal[len] = 0x00;
+ delete [] allocatedArray;
+ }
+ else
+ {
+ retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
+ retVal[0] = 0;
+ }
+ return retVal;
+}
+
bool Iconv390LCPTranscoder::transcode( const char* const toTranscode
, XMLCh* const toFill
diff --git a/src/xercesc/util/Transcoders/Iconv390/Iconv390TransService.hpp b/src/xercesc/util/Transcoders/Iconv390/Iconv390TransService.hpp
index 7dedfa42ab1acab2adaac39407bd73ee0aaa7e8a..c0221e34f508c586f6807a19632ae175862c1892 100644
--- a/src/xercesc/util/Transcoders/Iconv390/Iconv390TransService.hpp
+++ b/src/xercesc/util/Transcoders/Iconv390/Iconv390TransService.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:47:03 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2003/03/07 18:15:57 tng
* Return a reference instead of void for operator=
*
@@ -150,6 +153,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
@@ -179,6 +183,8 @@ public :
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
@@ -188,6 +194,8 @@ public :
);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/Iconv400/Iconv400TransService.cpp b/src/xercesc/util/Transcoders/Iconv400/Iconv400TransService.cpp
index 187ccc6d17d36fdccab67643b9d04e469ae90585..c5c2f85bb7e0fed69d8754ad5bf0ff4379e71e9a 100644
--- a/src/xercesc/util/Transcoders/Iconv400/Iconv400TransService.cpp
+++ b/src/xercesc/util/Transcoders/Iconv400/Iconv400TransService.cpp
@@ -316,7 +316,8 @@ XMLCh Iconv400TransService::toUnicodeLower(XMLCh comp1) const
XMLTranscoder*
Iconv400TransService::makeNewXMLTranscoder( const XMLCh* const encodingName
, XMLTransService::Codes& resValue
- , const unsigned int blockSize)
+ , const unsigned int blockSize
+ , MemoryManager* const manager)
{
UErrorCode uerr = U_ZERO_ERROR;
UConverter* converter = ucnv_openU(encodingName, &uerr);
@@ -325,7 +326,7 @@ Iconv400TransService::makeNewXMLTranscoder( const XMLCh* const enc
resValue = XMLTransService::UnsupportedEncoding;
return 0;
}
- return new Iconv400Transcoder(encodingName, converter, blockSize);
+ return new (manager) Iconv400Transcoder(encodingName, converter, blockSize);
}
@@ -769,6 +770,76 @@ char* Iconv400LCPTranscoder::transcode(const XMLCh* const toTranscode)
return retBuf;
}
+char* Iconv400LCPTranscoder::transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager)
+{
+ char* retBuf = 0;
+
+ // Check for a couple of special cases
+ if (!toTranscode)
+ return 0;
+
+ if (!*toTranscode)
+ {
+ retBuf = (char*) manager->allocate(sizeof(char));//new char[1];
+ retBuf[0] = 0;
+ return retBuf;
+ }
+
+ // Caculate a return buffer size not too big, but less likely to overflow
+ int32_t targetLen = (int32_t)(u_strlen(toTranscode) * 1.25);
+
+ // Allocate the return buffer
+ retBuf = (char*) manager->allocate((targetLen + 1) * sizeof(char));//new char[targetLen + 1];
+
+ // Lock now while we call the converter.
+ UErrorCode err = U_ZERO_ERROR;
+ int32_t targetCap;
+ {
+ XMLMutexLock lockConverter(&fMutex);
+
+ //Convert the Unicode string to char*
+ targetCap = ucnv_fromUChars
+ (
+ fConverter
+ , retBuf
+ , targetLen + 1
+ , toTranscode
+ , &err
+ );
+ }
+
+ // If targetLen is not enough then buffer overflow might occur
+ if (err == U_BUFFER_OVERFLOW_ERROR)
+ {
+ // Reset the error, delete the old buffer, allocate a new one, and try again
+ err = U_ZERO_ERROR;
+ manager->deallocate(retBuf);//delete [] retBuf;
+ retBuf = (char*) manager->allocate(targetCap * sizeof(char));//new char[targetCap];
+
+ // Lock again before we retry
+ XMLMutexLock lockConverter(&fMutex);
+ targetCap = ucnv_fromUChars
+ (
+ fConverter
+ , retBuf
+ , targetCap
+ , toTranscode
+ , &err
+ );
+ }
+
+ if (U_FAILURE(err))
+ {
+ manager->deallocate(retBuf);//delete [] retBuf;
+ return 0;
+ }
+
+ // Cap it off and return
+ retBuf[targetCap] = 0;
+ return retBuf;
+}
+
XMLCh* Iconv400LCPTranscoder::transcode(const char* const toTranscode)
{
// Watch for a few pyscho corner cases
@@ -840,6 +911,78 @@ XMLCh* Iconv400LCPTranscoder::transcode(const char* const toTranscode)
return retVal;
}
+XMLCh* Iconv400LCPTranscoder::transcode(const char* const toTranscode,
+ MemoryManager* const manager)
+{
+ // Watch for a few pyscho corner cases
+ if (!toTranscode)
+ return 0;
+
+ XMLCh* retVal = 0;
+ if (!*toTranscode)
+ {
+ retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
+ retVal[0] = 0;
+ return retVal;
+ }
+
+ //
+ // Get the length of the string to transcode. The Unicode string will
+ // almost always be no more chars than were in the source, so this is
+ // the best guess as to the storage needed.
+ //
+ const int32_t srcLen = (int32_t)strlen(toTranscode);
+ // Allocate unicode string of equivalent length in unicode bytes
+ retVal = (XMLCh*) manager->allocate((srcLen + 1) * sizeof(XMLCh));//new XMLCh[srcLen+1];
+
+ // Now lock while we do these calculations
+ UErrorCode err = U_ZERO_ERROR;
+ {
+ XMLMutexLock lockConverter(&fMutex);
+
+ //
+ // Here we don't know what the target length will be so use 0 and
+ // expect an U_BUFFER_OVERFLOW_ERROR in which case it'd get resolved
+ // by the correct capacity value.
+ //
+ int32_t targetCap;
+ targetCap = ucnv_toUChars
+ (
+ fConverter
+ , retVal
+ , srcLen+1
+ , toTranscode
+ , srcLen
+ , &err
+ );
+
+ if (err != U_BUFFER_OVERFLOW_ERROR)
+ {
+
+ err = U_ZERO_ERROR;
+ retVal = (XMLCh*) manager->allocate(targetCap * sizeof(XMLCh));//new XMLCh[targetCap];
+ ucnv_toUChars
+ (
+ fConverter
+ , retVal
+ , targetCap
+ , toTranscode
+ , srcLen
+ , &err
+ );
+ }
+ }
+
+ if (U_FAILURE(err))
+ {
+ // Clean up if we got anything allocated
+ manager->deallocate(retVal);//delete [] retVal;
+ return 0;
+ }
+
+ return retVal;
+}
+
bool Iconv400LCPTranscoder::transcode(const char* const toTranscode
, XMLCh* const toFill
diff --git a/src/xercesc/util/Transcoders/Iconv400/Iconv400TransService.hpp b/src/xercesc/util/Transcoders/Iconv400/Iconv400TransService.hpp
index a65c85ca8ebcd411f7074b17063e91ca83724f54..3814c89f789d15fb388bc2da213799857fa55b78 100644
--- a/src/xercesc/util/Transcoders/Iconv400/Iconv400TransService.hpp
+++ b/src/xercesc/util/Transcoders/Iconv400/Iconv400TransService.hpp
@@ -122,6 +122,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
@@ -237,8 +238,12 @@ public :
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.cpp b/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.cpp
index c0e2a57718e3abcd350b2adbb92fe552488ce605..17f084fc0b430fb3956f4bd94f2e440c69b3db13 100644
--- a/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.cpp
+++ b/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.12 2003/05/15 18:47:04 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.11 2003/03/09 17:02:57 peiyongz
* PanicHandler
*
@@ -842,6 +845,7 @@ IconvFBSDTransService::makeNewXMLTranscoder
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
)
{
#ifndef XML_USE_LIBICONV
@@ -860,7 +864,7 @@ IconvFBSDTransService::makeNewXMLTranscoder
resValue = XMLTransService::UnsupportedEncoding;
IconvFBSDTranscoder *newTranscoder = NULL;
- char *encLocal = XMLString::transcode(encodingName);
+ char *encLocal = XMLString::transcode(encodingName, manager);
iconv_t cd_from, cd_to;
{
@@ -869,7 +873,7 @@ IconvFBSDTransService::makeNewXMLTranscoder
if (cd_from == (iconv_t)-1) {
resValue = XMLTransService::SupportFilesNotFound;
if (encLocal)
- delete [] encLocal;
+ manager->deallocate(encLocal);//delete [] encLocal;
return NULL;
}
cd_to = iconv_open (encLocal, fUnicodeCP);
@@ -877,10 +881,10 @@ IconvFBSDTransService::makeNewXMLTranscoder
resValue = XMLTransService::SupportFilesNotFound;
iconv_close (cd_from);
if (encLocal)
- delete [] encLocal;
+ manager->deallocate(encLocal);//delete [] encLocal;
return NULL;
}
- newTranscoder = new IconvFBSDTranscoder (encodingName,
+ newTranscoder = new (manager) IconvFBSDTranscoder (encodingName,
blockSize,
cd_from, cd_to,
uChSize(), UBO());
@@ -888,7 +892,7 @@ IconvFBSDTransService::makeNewXMLTranscoder
if (newTranscoder)
resValue = XMLTransService::Ok;
if (encLocal)
- delete [] encLocal;
+ manager->deallocate(encLocal);//delete [] encLocal;
return newTranscoder;
#endif /* !XML_USE_LIBICONV */
diff --git a/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.hpp b/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.hpp
index 0dc918d069f455ffae51b83efb8cb71d64ba6894..27183fbbfaa296333f3cbfa46ee42330cb350f3a 100644
--- a/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.hpp
+++ b/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2003/05/15 18:47:04 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.6 2003/03/07 18:15:57 tng
* Return a reference instead of void for operator=
*
@@ -270,6 +273,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
@@ -401,6 +405,8 @@ public:
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
@@ -410,6 +416,8 @@ public:
);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp b/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp
index 4d369377786181b3cf97859545558b4e641b05bb..78e541ae5d13b9b85c3badb5a031a1d61bc4f75a 100644
--- a/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp
+++ b/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2003/05/15 18:47:05 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.6 2003/04/07 16:52:13 peiyongz
* Bug# 18672: IconvGNUTranscoder can't be build when namespaces is on.
* Patch from Bacek@yandex-team.ru (Vasily Tchekalkin)
@@ -658,12 +661,13 @@ IconvGNUTransService::makeNewXMLTranscoder
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
)
{
resValue = XMLTransService::UnsupportedEncoding;
IconvGNUTranscoder *newTranscoder = NULL;
- char *encLocal = XMLString::transcode(encodingName);
+ char *encLocal = XMLString::transcode(encodingName, manager);
iconv_t cd_from, cd_to;
{
@@ -672,7 +676,7 @@ IconvGNUTransService::makeNewXMLTranscoder
if (cd_from == (iconv_t)-1) {
resValue = XMLTransService::SupportFilesNotFound;
if (encLocal)
- delete [] encLocal;
+ manager->deallocate(encLocal);//delete [] encLocal;
return NULL;
}
cd_to = iconv_open (encLocal, fUnicodeCP);
@@ -680,10 +684,10 @@ IconvGNUTransService::makeNewXMLTranscoder
resValue = XMLTransService::SupportFilesNotFound;
iconv_close (cd_from);
if (encLocal)
- delete [] encLocal;
+ manager->deallocate(encLocal);//delete [] encLocal;
return NULL;
}
- newTranscoder = new IconvGNUTranscoder (encodingName,
+ newTranscoder = new (manager) IconvGNUTranscoder (encodingName,
blockSize,
cd_from, cd_to,
uChSize(), UBO());
@@ -691,7 +695,7 @@ IconvGNUTransService::makeNewXMLTranscoder
if (newTranscoder)
resValue = XMLTransService::Ok;
if (encLocal)
- delete [] encLocal;
+ manager->deallocate(encLocal);//delete [] encLocal;
return newTranscoder;
}
diff --git a/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.hpp b/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.hpp
index 7a942ef246317a93a7e57822a629ce03ea53eda1..4f645068017f7ede8be889aa7d140153ea9a8484 100644
--- a/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.hpp
+++ b/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:47:05 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2003/03/07 18:15:57 tng
* Return a reference instead of void for operator=
*
@@ -243,6 +246,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
@@ -359,6 +363,8 @@ public:
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
@@ -368,6 +374,8 @@ public:
);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.cpp b/src/xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.cpp
index 9a7e8f5b66ba64538b3c33e3288d2fe0e151b79d..797a2ef0088e1fd536bf7030fe9b0ce4972c20a3 100644
--- a/src/xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.cpp
+++ b/src/xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.cpp
@@ -533,7 +533,8 @@ MacOSUnicodeConverter::ConvertWideToNarrow(const XMLCh* wide, char* narrow, std:
XMLTranscoder*
MacOSUnicodeConverter::makeNewXMLTranscoder(const XMLCh* const encodingName
, XMLTransService::Codes& resValue
- , const unsigned int blockSize)
+ , const unsigned int blockSize
+ , MemoryManager* const manager)
{
XMLTranscoder* result = NULL;
resValue = XMLTransService::Ok;
@@ -578,7 +579,7 @@ MacOSUnicodeConverter::makeNewXMLTranscoder(const XMLCh* const encodingName
resValue = XMLTransService::UnsupportedEncoding;
}
else
- result = new MacOSTranscoder(encodingName, textToUnicodeInfo, unicodeToTextInfo, blockSize);
+ result = new (manager) MacOSTranscoder(encodingName, textToUnicodeInfo, unicodeToTextInfo, blockSize);
return result;
}
diff --git a/src/xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.hpp b/src/xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.hpp
index 3a4aab327378ad340b1ff7a397b1d9e5057c2a56..86c5c69e9cf9b8774f0700a0f1e1b5bc5011009c 100644
--- a/src/xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.hpp
+++ b/src/xercesc/util/Transcoders/MacOSUnicodeConverter/MacOSUnicodeConverter.hpp
@@ -129,6 +129,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
// Sniff for available functionality
@@ -253,8 +254,12 @@ public :
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/Uniconv390/Uniconv390TransService.cpp b/src/xercesc/util/Transcoders/Uniconv390/Uniconv390TransService.cpp
index a5587ac8498c63053acb97023cd4c47642026c2e..9e2a05449aab28ad5072fd2322a3993b0ed1f720 100644
--- a/src/xercesc/util/Transcoders/Uniconv390/Uniconv390TransService.cpp
+++ b/src/xercesc/util/Transcoders/Uniconv390/Uniconv390TransService.cpp
@@ -472,16 +472,17 @@ DBGPRINTF2("makeNewLCPTranscoder() localencoding=%s \n",nl_langinfo(CODESET));
XMLTranscoder* Uniconv390TransService::
makeNewXMLTranscoder(const XMLCh* const encodingName
, XMLTransService::Codes& resValue
- , const unsigned int blockSize)
+ , const unsigned int blockSize
+ , MemoryManager* const manager)
{
-char * localname = XMLString::transcode(encodingName);
-ArrayJanitor<char> janText((char*)localname);
+char * localname = XMLString::transcode(encodingName, manager);
+ArrayJanitor<char> janText((char*)localname, manager);
DBGPRINTF3("makeNewXMLTranscoder() encoding=%s blocksize=%d\n",localname,blockSize);
if (gForceTranscode == MUST_USE_ICU) {
if (gViewTranscoder)
printf("IXM1001I XML - Using ICU - %s\n",localname);
- return fICUService->makeNewXMLTranscoder(encodingName,resValue,blockSize);
+ return fICUService->makeNewXMLTranscoder(encodingName,resValue,blockSize, manager);
}
uniconvconverter *tconv=addConverter(localname,resValue);
@@ -493,13 +494,13 @@ DBGPRINTF3("makeNewXMLTranscoder() encoding=%s blocksize=%d\n",localname,blockSi
else {
if (gViewTranscoder)
printf("IXM1002I XML - Using ICU - %s\n",localname);
- return fICUService->makeNewXMLTranscoder(encodingName,resValue,blockSize);
+ return fICUService->makeNewXMLTranscoder(encodingName,resValue,blockSize, manager);
}
}
if (gViewTranscoder)
printf("IXM1003I XML - Using Unicode Services - %s\n",localname);
- return new Uniconv390Transcoder(encodingName, tconv, blockSize);
+ return new (manager) Uniconv390Transcoder(encodingName, tconv, blockSize);
}
@@ -772,6 +773,61 @@ char* Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode)
return retVal;
}
+char* Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager)
+{
+//printf("Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode) ");
+//printf("transcode handle=%x\n",fConverter->fIconv390DescriptorTo);
+ if (!toTranscode)
+ return 0;
+
+ char* retVal = 0;
+ // find out the length of the source and use this as an estimate for the needed buffer length.
+ unsigned int wLent = getWideCharLength(toTranscode);
+ if (wLent == 0) {
+ retVal = (char*) manager->allocate(sizeof(char));//new char[1];
+ retVal[0] = 0;
+ return retVal;
+ }
+ retVal = (char*) manager->allocate((wLent * 2 + 1) * sizeof(char));//new char[wLent * 2 + 1]; // get double just to be sure.
+ while (true) {
+ int retCode;
+ char *tmpInPtr = (char*) toTranscode;
+ char *tmpOutPtr = (char*) retVal;
+ unsigned int inByteLeft = wLent*sizeof(XMLCh);
+ unsigned int outByteLeft = wLent*sizeof(XMLCh);
+//printf("!!!transcode len=%d\n",wLent);
+
+ { // Locking scope
+ XMLMutexLock lockConverter(&fConverter->fMutex);
+ retCode = uniconv(fConverter->fIconv390DescriptorTo, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
+ }
+//printf("!!!transcode uniconv finished rc=%d errno=%d\n",retCode,errno);
+ // If the data does not fit into our estimation of the buffer size, then delete the buffer,
+ // double the estimated length and try again.
+ if ( ((retCode < 0) && (errno == E2BIG)) || (outByteLeft == 0) ) {
+//printf("!!!Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode):Retrying with a bigger buffer.......\n");
+ manager->deallocate(retVal);//delete [] retVal;
+ wLent*=2;
+ retVal = (char*) manager->allocate
+ (
+ (wLent*sizeof(XMLCh) + 1) * sizeof(char)
+ );//new char[wLent*sizeof(XMLCh) + 1];
+ }
+ // If uniconv doesn't complete for any other reason, then return failure.
+ else if (retCode < 0) {
+ return 0;
+ }
+ // it was successful so break out of the loop
+ else {
+ *tmpOutPtr = 0x00;
+ break;
+ }
+ }
+//printf("Uniconv390LCPTranscoder::transcode(const XMLCh* const toTranscode):%s\n",retVal);
+ return retVal;
+}
+
XMLCh* Uniconv390LCPTranscoder::transcode(const char* const toTranscode)
{
DBGPRINTF2("Uniconv390LCPTranscoder::transcode(const char* const toTranscode):%s \n",toTranscode);
@@ -808,6 +864,43 @@ DBGPRINTF2("Uniconv390LCPTranscoder::transcode(const char* const toTranscode):%s
return retVal;
}
+XMLCh* Uniconv390LCPTranscoder::transcode(const char* const toTranscode,
+ MemoryManager* const manager)
+{
+DBGPRINTF2("Uniconv390LCPTranscoder::transcode(const char* const toTranscode):%s \n",toTranscode);
+//printf("transcode handle=%x\n",fConverter->fIconv390DescriptorFrom);
+ if (!toTranscode)
+ return 0;
+
+ XMLCh* retVal = 0;
+ const unsigned int len = strlen(toTranscode);
+ retVal = (XMLCh*) manager->allocate((len + 1) * sizeof(XMLCh));//new XMLCh[len + 1]; // +1 is for the null terminator!
+ if (len == 0) {
+ retVal[0] = 0;
+ return retVal;
+ }
+
+ int retCode;
+ char *tmpInPtr = (char*) toTranscode;
+ char *tmpOutPtr = (char*) retVal;
+ unsigned int inByteLeft = len;
+ unsigned int outByteLeft = len*sizeof(XMLCh);
+ { // locking scope
+ XMLMutexLock lockConverter(&fConverter->fMutex);
+ retCode = uniconv(fConverter->fIconv390DescriptorFrom, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
+ }
+ // Because we check the length in the beginning, and we make sure the output buffer
+ // is big enough, uniconv should complete the transcoding. If it doesn't for any reason, then
+ // return failure.
+ if (retCode < 0) {
+ manager->deallocate(retVal);//delete [] retVal;
+ return 0;
+ }
+ *tmpOutPtr = 0x00;
+ *(tmpOutPtr+1) = 0x00;
+ return retVal;
+}
+
bool Uniconv390LCPTranscoder::transcode(const char* const toTranscode
, XMLCh* const toFill
diff --git a/src/xercesc/util/Transcoders/Uniconv390/Uniconv390TransService.hpp b/src/xercesc/util/Transcoders/Uniconv390/Uniconv390TransService.hpp
index 70440a664587047703b3d33a777348e7b999a93c..7ffbafb8e9fad20a7530af79c05188548478e3a1 100644
--- a/src/xercesc/util/Transcoders/Uniconv390/Uniconv390TransService.hpp
+++ b/src/xercesc/util/Transcoders/Uniconv390/Uniconv390TransService.hpp
@@ -126,6 +126,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
@@ -227,8 +228,12 @@ public :
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/Transcoders/Win32/Win32TransService.cpp b/src/xercesc/util/Transcoders/Win32/Win32TransService.cpp
index 9d960b2778131ca87539e8f56be7403cab2b6515..ab73a9bd7d7483d9bc88ff486c194293b1759536 100644
--- a/src/xercesc/util/Transcoders/Win32/Win32TransService.cpp
+++ b/src/xercesc/util/Transcoders/Win32/Win32TransService.cpp
@@ -537,7 +537,8 @@ bool Win32TransService::isAlias(const HKEY encodingKey
XMLTranscoder*
Win32TransService::makeNewXMLTranscoder(const XMLCh* const encodingName
, XMLTransService::Codes& resValue
- , const unsigned int blockSize)
+ , const unsigned int blockSize
+ , MemoryManager* const manager)
{
const unsigned int upLen = 1024;
XMLCh upEncoding[upLen + 1];
@@ -561,7 +562,7 @@ Win32TransService::makeNewXMLTranscoder(const XMLCh* const encoding
}
// We found it, so return a Win32 transcoder for this encoding
- return new Win32Transcoder
+ return new (manager) Win32Transcoder
(
encodingName
, theEntry->getWinCP()
@@ -902,6 +903,35 @@ char* Win32LCPTranscoder::transcode(const XMLCh* const toTranscode)
return retVal;
}
+char* Win32LCPTranscoder::transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager)
+{
+ if (!toTranscode)
+ return 0;
+
+ char* retVal = 0;
+ if (*toTranscode)
+ {
+ // Calc the needed size
+ const unsigned int neededLen = ::wcstombs(0, toTranscode, 0);
+ if (neededLen == (unsigned int)-1)
+ return 0;
+
+ // Allocate a buffer of that size plus one for the null and transcode
+ retVal = (char*) manager->allocate((neededLen + 1) * sizeof(char)); //new char[neededLen + 1];
+ ::wcstombs(retVal, toTranscode, neededLen + 1);
+
+ // And cap it off anyway just to make sure
+ retVal[neededLen] = 0;
+ }
+ else
+ {
+ retVal = (char*) manager->allocate(sizeof(char)); //new char[1];
+ retVal[0] = 0;
+ }
+ return retVal;
+}
+
XMLCh* Win32LCPTranscoder::transcode(const char* const toTranscode)
{
@@ -935,6 +965,39 @@ XMLCh* Win32LCPTranscoder::transcode(const char* const toTranscode)
return retVal;
}
+XMLCh* Win32LCPTranscoder::transcode(const char* const toTranscode,
+ MemoryManager* const manager)
+{
+ if (!toTranscode)
+ return 0;
+
+ XMLCh* retVal = 0;
+ if (*toTranscode)
+ {
+ // Calculate the buffer size required
+ const unsigned int neededLen = calcRequiredSize(toTranscode);
+ if (neededLen == 0)
+ {
+ retVal = (XMLCh*) manager->allocate(sizeof(XMLCh)); //new XMLCh[1];
+ retVal[0] = 0;
+ return retVal;
+ }
+
+ // Allocate a buffer of that size plus one for the null and transcode
+ retVal = (XMLCh*) manager->allocate((neededLen + 1) * sizeof(XMLCh)); //new XMLCh[neededLen + 1];
+ ::mbstowcs(retVal, toTranscode, neededLen + 1);
+
+ // Cap it off just to make sure. We are so paranoid!
+ retVal[neededLen] = 0;
+ }
+ else
+ {
+ retVal = (XMLCh*) manager->allocate(sizeof(XMLCh*)); //new XMLCh[1];
+ retVal[0] = 0;
+ }
+ return retVal;
+}
+
bool Win32LCPTranscoder::transcode( const char* const toTranscode
, XMLCh* const toFill
diff --git a/src/xercesc/util/Transcoders/Win32/Win32TransService.hpp b/src/xercesc/util/Transcoders/Win32/Win32TransService.hpp
index 40b73d878d1c1b41876e6328eeee8044c9874bbb..d29814b311c6fada81f0bd38ff547ce9952d4755 100644
--- a/src/xercesc/util/Transcoders/Win32/Win32TransService.hpp
+++ b/src/xercesc/util/Transcoders/Win32/Win32TransService.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:47:07 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2003/03/07 18:15:58 tng
* Return a reference instead of void for operator=
*
@@ -177,6 +180,7 @@ protected :
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
+ , MemoryManager* const manager
);
@@ -309,8 +313,12 @@ public :
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
+ virtual char* transcode(const XMLCh* const toTranscode,
+ MemoryManager* const manager);
virtual XMLCh* transcode(const char* const toTranscode);
+ virtual XMLCh* transcode(const char* const toTranscode,
+ MemoryManager* const manager);
virtual bool transcode
(
diff --git a/src/xercesc/util/regx/BMPattern.cpp b/src/xercesc/util/regx/BMPattern.cpp
index bad554bef55bdbc9391255088e21555a475dba4e..0b230ec743be1138c052388976658a853720bb33 100644
--- a/src/xercesc/util/regx/BMPattern.cpp
+++ b/src/xercesc/util/regx/BMPattern.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:42:54 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 15:17:00 tng
* C++ Namespace Support.
*
@@ -76,20 +79,26 @@
#include <xercesc/util/regx/BMPattern.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/Janitor.hpp>
+#include <xercesc/framework/MemoryManager.hpp>
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// BMPattern: Constructors
// ---------------------------------------------------------------------------
-BMPattern::BMPattern(const XMLCh* const pattern, bool ignoreCase)
- :fPattern(XMLString::replicate(pattern)),
- fUppercasePattern(0),
- fIgnoreCase(ignoreCase),
- fShiftTable(0),
- fShiftTableLen(256) {
-
+BMPattern::BMPattern( const XMLCh* const pattern
+ , bool ignoreCase
+ , MemoryManager* const manager) :
+
+ fIgnoreCase(ignoreCase)
+ , fShiftTableLen(256)
+ , fShiftTable(0)
+ , fPattern(0)
+ , fUppercasePattern(0)
+ , fMemoryManager(manager)
+{
try {
+ fPattern = XMLString::replicate(pattern, fMemoryManager);
initialize();
}
catch(...) {
@@ -99,14 +108,20 @@ BMPattern::BMPattern(const XMLCh* const pattern, bool ignoreCase)
}
}
-BMPattern::BMPattern(const XMLCh* const pattern, int tableSize, bool ignoreCase)
- :fPattern(XMLString::replicate(pattern)),
- fUppercasePattern(0),
- fIgnoreCase(ignoreCase),
- fShiftTable(0),
- fShiftTableLen(tableSize) {
-
+BMPattern::BMPattern( const XMLCh* const pattern
+ , int tableSize
+ , bool ignoreCase
+ , MemoryManager* const manager) :
+
+ fIgnoreCase(ignoreCase)
+ , fShiftTableLen(tableSize)
+ , fShiftTable(0)
+ , fPattern(0)
+ , fUppercasePattern(0)
+ , fMemoryManager(manager)
+{
try {
+ fPattern = XMLString::replicate(pattern, fMemoryManager);
initialize();
}
catch(...) {
@@ -135,11 +150,11 @@ int BMPattern::matches(const XMLCh* const content, int start, int limit) {
if (fIgnoreCase) {
- ucContent = XMLString::replicate(content);
+ ucContent = XMLString::replicate(content, fMemoryManager);
XMLString::upperCase(ucContent);
}
- ArrayJanitor<XMLCh> janUCContent(ucContent);
+ ArrayJanitor<XMLCh> janUCContent(ucContent, fMemoryManager);
int index = start + patternLen;
@@ -184,17 +199,17 @@ void BMPattern::initialize() {
const unsigned int patternLen = XMLString::stringLen(fPattern);
XMLCh* lowercasePattern = 0;
- fShiftTable = new int[fShiftTableLen];
+ fShiftTable = (int*) fMemoryManager->allocate(fShiftTableLen*sizeof(int)); //new int[fShiftTableLen];
if (fIgnoreCase) {
- fUppercasePattern = XMLString::replicate(fPattern);
- lowercasePattern = XMLString::replicate(fPattern);
+ fUppercasePattern = XMLString::replicate(fPattern, fMemoryManager);
+ lowercasePattern = XMLString::replicate(fPattern, fMemoryManager);
XMLString::upperCase(fUppercasePattern);
XMLString::lowerCase(lowercasePattern);
}
- ArrayJanitor<XMLCh> janLowercase(lowercasePattern);
+ ArrayJanitor<XMLCh> janLowercase(lowercasePattern, fMemoryManager);
for (unsigned int i=0; i< fShiftTableLen; i++)
fShiftTable[i] = patternLen;
@@ -222,6 +237,16 @@ void BMPattern::initialize() {
}
}
+// ---------------------------------------------------------------------------
+// BMPattern: Cleanup
+// ---------------------------------------------------------------------------
+void BMPattern::cleanUp() {
+
+ fMemoryManager->deallocate(fPattern);//delete [] fPattern;
+ fMemoryManager->deallocate(fUppercasePattern);//delete [] fUppercasePattern;
+ fMemoryManager->deallocate(fShiftTable);
+}
+
XERCES_CPP_NAMESPACE_END
/**
diff --git a/src/xercesc/util/regx/BMPattern.hpp b/src/xercesc/util/regx/BMPattern.hpp
index aed51880db722c2a0ae8941d3cfce956a114b5ed..9ae02526a912c3c1fdd3d5cb828ca66c4043a8e2 100644
--- a/src/xercesc/util/regx/BMPattern.hpp
+++ b/src/xercesc/util/regx/BMPattern.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -63,11 +63,13 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/util/XMemory.hpp>
+#include <xercesc/util/PlatformUtils.hpp>
XERCES_CPP_NAMESPACE_BEGIN
-class XMLUTIL_EXPORT BMPattern {
+class XMLUTIL_EXPORT BMPattern : public XMemory
+{
public:
// -----------------------------------------------------------------------
// Public Constructors and Destructor
@@ -83,8 +85,15 @@ public:
*
* @param ignoreCase A flag to indicate whether to ignore case
* matching or not.
+ *
+ * @param manager The configurable memory manager
*/
- BMPattern(const XMLCh* const pattern, bool ignoreCase);
+ BMPattern
+ (
+ const XMLCh* const pattern
+ , bool ignoreCase
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
/**
* This is the constructor which takes all of the information
@@ -96,8 +105,16 @@ public:
*
* @param ignoreCase A flag to indicate whether to ignore case
* matching or not.
+ *
+ * @param manager The configurable memory manager
*/
- BMPattern(const XMLCh* const pattern, int tableSize, bool ignoreCase);
+ BMPattern
+ (
+ const XMLCh* const pattern
+ , int tableSize
+ , bool ignoreCase
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
//@}
@@ -160,23 +177,14 @@ private :
// This is a table of offsets for shifting purposes used by the BM
// search algorithm, and its length.
// -----------------------------------------------------------------------
- XMLCh* fPattern;
- XMLCh* fUppercasePattern;
- bool fIgnoreCase;
- int* fShiftTable;
- unsigned int fShiftTableLen;
+ bool fIgnoreCase;
+ unsigned int fShiftTableLen;
+ int* fShiftTable;
+ XMLCh* fPattern;
+ XMLCh* fUppercasePattern;
+ MemoryManager* fMemoryManager;
};
-// ---------------------------------------------------------------------------
-// BMPattern: Cleanup
-// ---------------------------------------------------------------------------
-inline void BMPattern::cleanUp() {
-
- delete [] fPattern;
- delete [] fUppercasePattern;
- delete [] fShiftTable;
-}
-
XERCES_CPP_NAMESPACE_END
#endif
diff --git a/src/xercesc/util/regx/Match.hpp b/src/xercesc/util/regx/Match.hpp
index 4a4e507fc7192b382b0aeb293626d1f5fbefe627..9a6e84555f8a7bad52670a2d7c524e25ea3fa1e7 100644
--- a/src/xercesc/util/regx/Match.hpp
+++ b/src/xercesc/util/regx/Match.hpp
@@ -72,7 +72,8 @@ XERCES_CPP_NAMESPACE_BEGIN
/**
* An instance of this class has ranges captured in matching
*/
-class XMLUTIL_EXPORT Match {
+ class XMLUTIL_EXPORT Match : public XMemory
+{
public:
// -----------------------------------------------------------------------
diff --git a/src/xercesc/util/regx/Op.hpp b/src/xercesc/util/regx/Op.hpp
index 1259b11277fc843521acba4fb4c13fec542c143b..d224f14a0592c99f4df90726b042f99d07f9ebd1 100644
--- a/src/xercesc/util/regx/Op.hpp
+++ b/src/xercesc/util/regx/Op.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -64,7 +64,6 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/util/RefVectorOf.hpp>
#include <xercesc/util/RuntimeException.hpp>
@@ -76,7 +75,8 @@ XERCES_CPP_NAMESPACE_BEGIN
class Token;
-class XMLUTIL_EXPORT Op {
+class XMLUTIL_EXPORT Op : public XMemory
+{
public:
enum {
diff --git a/src/xercesc/util/regx/OpFactory.cpp b/src/xercesc/util/regx/OpFactory.cpp
index 349b6944600f0c58e7019d0be69aba3997bfe342..86fdc7d0850fee43c7dfa6f81897b515e0616ec4 100644
--- a/src/xercesc/util/regx/OpFactory.cpp
+++ b/src/xercesc/util/regx/OpFactory.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:42:54 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/11/04 15:17:00 tng
* C++ Namespace Support.
*
@@ -81,6 +84,7 @@
// ---------------------------------------------------------------------------
#include <xercesc/util/regx/OpFactory.hpp>
#include <xercesc/util/regx/Op.hpp>
+#include <xercesc/util/PlatformUtils.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -88,8 +92,10 @@ XERCES_CPP_NAMESPACE_BEGIN
// OpFactory: Constructors and Destructor
// ---------------------------------------------------------------------------
OpFactory::OpFactory() :
- fOpVector(new RefVectorOf<Op>(16, true)) {
-
+ fOpVector(0)
+ , fMemoryManager(XMLPlatformUtils::fgMemoryManager)
+{
+ fOpVector = new (fMemoryManager) RefVectorOf<Op>(16, true);
}
OpFactory::~OpFactory() {
@@ -103,14 +109,14 @@ OpFactory::~OpFactory() {
// ---------------------------------------------------------------------------
Op* OpFactory::createDotOp() {
- Op* tmpOp = new Op(Op::O_DOT);
+ Op* tmpOp = new (fMemoryManager) Op(Op::O_DOT);
fOpVector->addElement(tmpOp);
return tmpOp;
}
CharOp* OpFactory::createCharOp(int data) {
- CharOp* tmpOp = new CharOp(Op::O_CHAR, data);
+ CharOp* tmpOp = new (fMemoryManager) CharOp(Op::O_CHAR, data);
fOpVector->addElement(tmpOp);
return tmpOp;
@@ -118,7 +124,7 @@ CharOp* OpFactory::createCharOp(int data) {
CharOp* OpFactory::createAnchorOp(int data) {
- CharOp* tmpOp = new CharOp(Op::O_ANCHOR, data);
+ CharOp* tmpOp = new (fMemoryManager) CharOp(Op::O_ANCHOR, data);
fOpVector->addElement(tmpOp);
return tmpOp;
@@ -126,7 +132,7 @@ CharOp* OpFactory::createAnchorOp(int data) {
CharOp* OpFactory::createCaptureOp(int number, const Op* const next) {
- CharOp* tmpOp = new CharOp(Op::O_CAPTURE, number);
+ CharOp* tmpOp = new (fMemoryManager) CharOp(Op::O_CAPTURE, number);
tmpOp->setNextOp(next);
fOpVector->addElement(tmpOp);
@@ -135,7 +141,7 @@ CharOp* OpFactory::createCaptureOp(int number, const Op* const next) {
UnionOp* OpFactory::createUnionOp(int size) {
- UnionOp* tmpOp = new UnionOp(Op::O_UNION, size);
+ UnionOp* tmpOp = new (fMemoryManager) UnionOp(Op::O_UNION, size);
fOpVector->addElement(tmpOp);
return tmpOp;
@@ -143,7 +149,7 @@ UnionOp* OpFactory::createUnionOp(int size) {
ChildOp* OpFactory::createClosureOp(int id) {
- ModifierOp* tmpOp = new ModifierOp(Op::O_CLOSURE, id, -1);
+ ModifierOp* tmpOp = new (fMemoryManager) ModifierOp(Op::O_CLOSURE, id, -1);
fOpVector->addElement(tmpOp);
return tmpOp;
@@ -151,7 +157,7 @@ ChildOp* OpFactory::createClosureOp(int id) {
ChildOp* OpFactory::createNonGreedyClosureOp() {
- ChildOp* tmpOp = new ChildOp(Op::O_NONGREEDYCLOSURE);
+ ChildOp* tmpOp = new (fMemoryManager) ChildOp(Op::O_NONGREEDYCLOSURE);
fOpVector->addElement(tmpOp);
return tmpOp;
@@ -159,7 +165,7 @@ ChildOp* OpFactory::createNonGreedyClosureOp() {
ChildOp* OpFactory::createQuestionOp(bool nonGreedy) {
- ChildOp* tmpOp = new ChildOp(nonGreedy ? Op::O_NONGREEDYQUESTION :
+ ChildOp* tmpOp = new (fMemoryManager) ChildOp(nonGreedy ? Op::O_NONGREEDYQUESTION :
Op::O_QUESTION);
fOpVector->addElement(tmpOp);
@@ -168,7 +174,7 @@ ChildOp* OpFactory::createQuestionOp(bool nonGreedy) {
RangeOp* OpFactory::createRangeOp(const Token* const token) {
- RangeOp* tmpOp = new RangeOp(Op::O_RANGE, token);
+ RangeOp* tmpOp = new (fMemoryManager) RangeOp(Op::O_RANGE, token);
fOpVector->addElement(tmpOp);
return tmpOp;
@@ -177,7 +183,7 @@ RangeOp* OpFactory::createRangeOp(const Token* const token) {
ChildOp* OpFactory::createLookOp(const short type, const Op* const next,
const Op* const branch) {
- ChildOp* tmpOp = new ChildOp(type);
+ ChildOp* tmpOp = new (fMemoryManager) ChildOp(type);
tmpOp->setNextOp(next);
tmpOp->setChild(branch);
@@ -187,7 +193,7 @@ ChildOp* OpFactory::createLookOp(const short type, const Op* const next,
CharOp* OpFactory::createBackReferenceOp(int refNo) {
- CharOp* tmpOp = new CharOp(Op::O_BACKREFERENCE, refNo);
+ CharOp* tmpOp = new (fMemoryManager) CharOp(Op::O_BACKREFERENCE, refNo);
fOpVector->addElement(tmpOp);
return tmpOp;
@@ -195,7 +201,7 @@ CharOp* OpFactory::createBackReferenceOp(int refNo) {
StringOp* OpFactory::createStringOp(const XMLCh* const literal) {
- StringOp* tmpOp = new StringOp(Op::O_STRING, literal);
+ StringOp* tmpOp = new (fMemoryManager) StringOp(Op::O_STRING, literal);
fOpVector->addElement(tmpOp);
return tmpOp;
@@ -204,7 +210,7 @@ StringOp* OpFactory::createStringOp(const XMLCh* const literal) {
ChildOp* OpFactory::createIndependentOp(const Op* const next,
const Op* const branch) {
- ChildOp* tmpOp = new ChildOp(Op::O_INDEPENDENT);
+ ChildOp* tmpOp = new (fMemoryManager) ChildOp(Op::O_INDEPENDENT);
tmpOp->setNextOp(next);
tmpOp->setChild(branch);
@@ -216,7 +222,7 @@ ModifierOp* OpFactory::createModifierOp(const Op* const next,
const Op* const branch,
const int add, const int mask) {
- ModifierOp* tmpOp = new ModifierOp(Op::O_MODIFIER, add, mask);
+ ModifierOp* tmpOp = new (fMemoryManager) ModifierOp(Op::O_MODIFIER, add, mask);
tmpOp->setNextOp(next);
tmpOp->setChild(branch);
@@ -228,7 +234,7 @@ ConditionOp* OpFactory::createConditionOp(const Op* const next, const int ref,
const Op* const yesFlow,
const Op* const noFlow) {
- ConditionOp* tmpOp = new ConditionOp(Op::O_CONDITION, ref, conditionFlow,
+ ConditionOp* tmpOp = new (fMemoryManager) ConditionOp(Op::O_CONDITION, ref, conditionFlow,
yesFlow, noFlow);
tmpOp->setNextOp(next);
diff --git a/src/xercesc/util/regx/OpFactory.hpp b/src/xercesc/util/regx/OpFactory.hpp
index e2deac76a64bc45c31a4398d7680729e85faf62f..75c723a8efa29900c62b602e9090109f930c4605 100644
--- a/src/xercesc/util/regx/OpFactory.hpp
+++ b/src/xercesc/util/regx/OpFactory.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -64,7 +64,7 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XMLUniDefs.hpp>
+#include <xercesc/util/XMemory.hpp>
#include <xercesc/util/RefVectorOf.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -90,8 +90,8 @@ class Token;
* all associated Op objects will be deleted.
*/
-class XMLUTIL_EXPORT OpFactory {
-
+class XMLUTIL_EXPORT OpFactory : public XMemory
+{
public:
// -----------------------------------------------------------------------
// Constructors and destructors
@@ -146,6 +146,7 @@ private:
// Contains Op objects. Used for memory cleanup.
// -----------------------------------------------------------------------
RefVectorOf<Op>* fOpVector;
+ MemoryManager* fMemoryManager;
};
// ---------------------------------------------------------------------------
diff --git a/src/xercesc/util/regx/ParserForXMLSchema.cpp b/src/xercesc/util/regx/ParserForXMLSchema.cpp
index e2a8378c1221911719906a83ba96db5eff2d426c..2dc212862a6ef5c206480c4cbaf049a46eee6c80 100644
--- a/src/xercesc/util/regx/ParserForXMLSchema.cpp
+++ b/src/xercesc/util/regx/ParserForXMLSchema.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:42:54 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2003/03/18 19:38:28 knoaman
* Schema Errata E2-18 + misc. regex fixes.
*
@@ -114,14 +117,15 @@
#include <xercesc/util/regx/RegxDefs.hpp>
#include <xercesc/util/ParseException.hpp>
#include <xercesc/util/RuntimeException.hpp>
+#include <xercesc/util/PlatformUtils.hpp>
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// ParserForXMLSchema: Constructors and Destructors
// ---------------------------------------------------------------------------
-ParserForXMLSchema::ParserForXMLSchema()
- : RegxParser()
+ParserForXMLSchema::ParserForXMLSchema(MemoryManager* const manager)
+ : RegxParser(manager)
{
}
diff --git a/src/xercesc/util/regx/ParserForXMLSchema.hpp b/src/xercesc/util/regx/ParserForXMLSchema.hpp
index 1c4a1701f2c92062f5aaf140daf4f0a2eeb5e9d6..646172569889384e336f740173388fed9b60b61b 100644
--- a/src/xercesc/util/regx/ParserForXMLSchema.hpp
+++ b/src/xercesc/util/regx/ParserForXMLSchema.hpp
@@ -79,7 +79,7 @@ public:
// -----------------------------------------------------------------------
// Public Constructors and Destructor
// -----------------------------------------------------------------------
- ParserForXMLSchema();
+ ParserForXMLSchema(MemoryManager* const manager);
~ParserForXMLSchema();
// -----------------------------------------------------------------------
diff --git a/src/xercesc/util/regx/RangeFactory.hpp b/src/xercesc/util/regx/RangeFactory.hpp
index fde574dda4ef7d0f69f927f2e9ee525218becf32..8b183227d3fd57c060086508d432d381f88e89aa 100644
--- a/src/xercesc/util/regx/RangeFactory.hpp
+++ b/src/xercesc/util/regx/RangeFactory.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -64,12 +64,12 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/util/XMemory.hpp>
XERCES_CPP_NAMESPACE_BEGIN
-class XMLUTIL_EXPORT RangeFactory {
-
+class XMLUTIL_EXPORT RangeFactory : public XMemory
+{
public:
// -----------------------------------------------------------------------
// Constructors and destructors
diff --git a/src/xercesc/util/regx/RangeTokenMap.hpp b/src/xercesc/util/regx/RangeTokenMap.hpp
index 9f977e9cb9ce718105f2d8b13691fd756081caca..9960387bb478c7080b5af2f9a3407c17ab178867 100644
--- a/src/xercesc/util/regx/RangeTokenMap.hpp
+++ b/src/xercesc/util/regx/RangeTokenMap.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -64,8 +64,8 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/StringPool.hpp>
#include <xercesc/util/Mutexes.hpp>
+#include <xercesc/util/RefHashTableOf.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -75,9 +75,10 @@ XERCES_CPP_NAMESPACE_BEGIN
class RangeToken;
class RangeFactory;
class TokenFactory;
+class XMLStringPool;
-
-class XMLUTIL_EXPORT RangeTokenElemMap {
+class XMLUTIL_EXPORT RangeTokenElemMap : public XMemory
+{
public:
RangeTokenElemMap(unsigned int categoryId);
@@ -109,8 +110,8 @@ private:
};
-class XMLUTIL_EXPORT RangeTokenMap {
-
+class XMLUTIL_EXPORT RangeTokenMap : public XMemory
+{
public:
// -----------------------------------------------------------------------
// Putter methods
diff --git a/src/xercesc/util/regx/RegularExpression.cpp b/src/xercesc/util/regx/RegularExpression.cpp
index 4a39a38e5a6af2d9a3e6aaba66376fd005f7346e..a9385f944e1af282d23abb7e1ce0eebbd60d5dfd 100644
--- a/src/xercesc/util/regx/RegularExpression.cpp
+++ b/src/xercesc/util/regx/RegularExpression.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.8 2003/05/15 18:42:54 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.7 2003/05/12 10:08:22 gareth
* The correct file this time.
*
@@ -119,6 +122,7 @@
#include <xercesc/util/regx/ParserForXMLSchema.hpp>
#include <xercesc/util/Janitor.hpp>
#include <xercesc/util/ParseException.hpp>
+#include <xercesc/util/IllegalArgumentException.hpp>
#include <xercesc/framework/XMLBuffer.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -357,7 +361,7 @@ void RegularExpression::setPattern(const XMLCh* const pattern,
fPattern = XMLString::replicate(pattern);
RegxParser* regxParser = isSet(fOptions, XMLSCHEMA_MODE)
- ? new ParserForXMLSchema() : new RegxParser();
+ ? new ParserForXMLSchema(XMLPlatformUtils::fgMemoryManager) : new RegxParser(XMLPlatformUtils::fgMemoryManager);
if (regxParser) {
regxParser->setTokenFactory(fTokenFactory);
diff --git a/src/xercesc/util/regx/RegularExpression.hpp b/src/xercesc/util/regx/RegularExpression.hpp
index 26b0474550d95c57bef669a7087beb8cc9f5f235..71d82483cebc4029441d113db5c960891c00c3e3 100644
--- a/src/xercesc/util/regx/RegularExpression.hpp
+++ b/src/xercesc/util/regx/RegularExpression.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -64,14 +64,13 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/RefArrayVectorOf.hpp>
#include <xercesc/util/XMLString.hpp>
+#include <xercesc/util/Janitor.hpp>
+#include <xercesc/util/Mutexes.hpp>
#include <xercesc/util/regx/Op.hpp>
#include <xercesc/util/regx/TokenFactory.hpp>
#include <xercesc/util/regx/BMPattern.hpp>
-#include <xercesc/util/Janitor.hpp>
-#include <xercesc/util/Mutexes.hpp>
#include <xercesc/util/regx/ModifierToken.hpp>
#include <xercesc/util/regx/ConditionToken.hpp>
#include <xercesc/util/regx/OpFactory.hpp>
@@ -81,13 +80,11 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Forward Declaration
// ---------------------------------------------------------------------------
-class Token;
-class BMPattern;
class RangeToken;
class Match;
-class TokenFactory;
-class XMLUTIL_EXPORT RegularExpression {
+class XMLUTIL_EXPORT RegularExpression : public XMemory
+{
public:
// -----------------------------------------------------------------------
// Public Constructors and Destructor
@@ -168,7 +165,7 @@ private:
// -----------------------------------------------------------------------
// Private data types
// -----------------------------------------------------------------------
- class XMLUTIL_EXPORT Context
+ class XMLUTIL_EXPORT Context : public XMemory
{
public :
Context();
diff --git a/src/xercesc/util/regx/RegxParser.cpp b/src/xercesc/util/regx/RegxParser.cpp
index f946438c08cba786edbe8ad06f8a7133ac637991..d6b000ae4fe2f69b6e3993253e389f8e05e37da8 100644
--- a/src/xercesc/util/regx/RegxParser.cpp
+++ b/src/xercesc/util/regx/RegxParser.cpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2003/05/15 18:42:55 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.6 2003/03/18 19:38:28 knoaman
* Schema Errata E2-18 + misc. regex fixes.
*
@@ -122,14 +125,13 @@
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/regx/RegxParser.hpp>
-#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
+#include <xercesc/util/ParseException.hpp>
#include <xercesc/util/regx/RegularExpression.hpp>
#include <xercesc/util/regx/RegxUtil.hpp>
#include <xercesc/util/regx/RegxDefs.hpp>
#include <xercesc/util/regx/TokenInc.hpp>
#include <xercesc/framework/XMLErrorCodes.hpp>
-#include <xercesc/util/ParseException.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -144,7 +146,7 @@ const unsigned short RegxParser::S_INXBRACKETS = 2;
// RegxParser::ReferencePostion: Constructors and Destructor
// ---------------------------------------------------------------------------
RegxParser::ReferencePosition::ReferencePosition(const int refNo,
- const int position)
+ const int position)
:fReferenceNo(refNo)
, fPosition(position)
{
@@ -154,8 +156,9 @@ RegxParser::ReferencePosition::ReferencePosition(const int refNo,
// ---------------------------------------------------------------------------
// RegxParser: Constructors and Destructors
// ---------------------------------------------------------------------------
-RegxParser::RegxParser()
- :fHasBackReferences(false),
+RegxParser::RegxParser(MemoryManager* const manager)
+ :fMemoryManager(manager),
+ fHasBackReferences(false),
fOptions(0),
fOffset(0),
fNoGroups(1),
@@ -171,7 +174,7 @@ RegxParser::RegxParser()
RegxParser::~RegxParser() {
- delete [] fString;
+ fMemoryManager->deallocate(fString);//delete [] fString;
delete fReferences;
}
@@ -193,13 +196,15 @@ Token* RegxParser::parse(const XMLCh* const regxStr, const int options) {
fNoGroups = 1;
fHasBackReferences = false;
setParseContext(S_NORMAL);
- delete [] fString;
- fString = XMLString::replicate(regxStr);
+ if (fString)
+ fMemoryManager->deallocate(fString);//delete [] fString;
+ fString = XMLString::replicate(regxStr, fMemoryManager);
if (isSet(RegularExpression::EXTENDED_COMMENT)) {
- delete [] fString;
- fString = RegxUtil::stripExtendedComment(regxStr);
+ if (fString)
+ fMemoryManager->deallocate(fString);//delete [] fString;
+ fString = RegxUtil::stripExtendedComment(regxStr, fMemoryManager);
}
fStringLen = XMLString::stringLen(fString);
@@ -648,10 +653,10 @@ Token* RegxParser::processCondition() {
fHasBackReferences = true;
if (fReferences == 0) {
- this->fReferences = new RefVectorOf<ReferencePosition>(8, true);
+ this->fReferences = new (fMemoryManager) RefVectorOf<ReferencePosition>(8, true);
}
- fReferences->addElement(new ReferencePosition(refNo, fOffset));
+ fReferences->addElement(new (fMemoryManager) ReferencePosition(refNo, fOffset));
fOffset++;
if (fString[fOffset] != chCloseParen)
@@ -840,10 +845,10 @@ Token* RegxParser::processBackReference() {
fHasBackReferences = true;
if (fReferences == 0) {
- fReferences = new RefVectorOf<ReferencePosition>(8, true);
+ fReferences = new (fMemoryManager) RefVectorOf<ReferencePosition>(8, true);
}
- fReferences->addElement(new ReferencePosition(refNo, fOffset - 2));
+ fReferences->addElement(new (fMemoryManager) ReferencePosition(refNo, fOffset - 2));
processNext();
return tok;
}
@@ -1090,8 +1095,11 @@ RangeToken* RegxParser::processBacksolidus_pP(const XMLInt32 ch) {
ThrowXML(ParseException,XMLExcepts::Parser_Atom3);
fOffset = nameEnd + 1;
- XMLCh* rangeName = new XMLCh[(nameEnd - nameStart) + 1];
- ArrayJanitor<XMLCh> janRangeName(rangeName);
+ XMLCh* rangeName = (XMLCh*) fMemoryManager->allocate
+ (
+ (nameEnd - nameStart + 1) * sizeof(XMLCh)
+ );//new XMLCh[(nameEnd - nameStart) + 1];
+ ArrayJanitor<XMLCh> janRangeName(rangeName, fMemoryManager);
XMLString::subString(rangeName, fString, nameStart, nameEnd);
return fTokenFactory->getRange(rangeName, !(ch == chLatin_p));
@@ -1199,8 +1207,11 @@ RangeToken* RegxParser::parseCharacterClass(const bool useNRange) {
positive = false;
}
- XMLCh* name = new XMLCh[(nameEnd - fOffset) + 1];
- ArrayJanitor<XMLCh> janName(name);
+ XMLCh* name = (XMLCh*) fMemoryManager->allocate
+ (
+ (nameEnd - fOffset + 1) * sizeof(XMLCh)
+ );//new XMLCh[(nameEnd - fOffset) + 1];
+ ArrayJanitor<XMLCh> janName(name, fMemoryManager);
XMLString::subString(name, fString, fOffset, nameEnd);
RangeToken* rangeTok = fTokenFactory->getRange(name, !positive);
diff --git a/src/xercesc/util/regx/RegxParser.hpp b/src/xercesc/util/regx/RegxParser.hpp
index ee96324ab4353ceb309da0ba181a38180b138483..db98b10de499687eef19c2d90a487ca0e5271e0d 100644
--- a/src/xercesc/util/regx/RegxParser.hpp
+++ b/src/xercesc/util/regx/RegxParser.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -80,7 +80,8 @@ class Token;
class RangeToken;
class TokenFactory;
-class XMLUTIL_EXPORT RegxParser {
+class XMLUTIL_EXPORT RegxParser : public XMemory
+{
public:
// -----------------------------------------------------------------------
@@ -122,7 +123,7 @@ public:
// -----------------------------------------------------------------------
// Public Constructors and Destructor
// -----------------------------------------------------------------------
- RegxParser();
+ RegxParser(MemoryManager* const manager);
virtual ~RegxParser();
// -----------------------------------------------------------------------
@@ -206,7 +207,7 @@ private:
// -----------------------------------------------------------------------
// Private data types
// -----------------------------------------------------------------------
- class ReferencePosition
+ class ReferencePosition : public XMemory
{
public :
ReferencePosition(const int refNo, const int position);
@@ -224,6 +225,7 @@ private:
// -----------------------------------------------------------------------
// Private data members
// -----------------------------------------------------------------------
+ MemoryManager* fMemoryManager;
bool fHasBackReferences;
int fOptions;
int fOffset;
diff --git a/src/xercesc/util/regx/RegxUtil.cpp b/src/xercesc/util/regx/RegxUtil.cpp
index b67102c9364e3725d8d6a4c22b0c94f63c7b8e80..fec10cb0e4781932335de0ae809f441a1edda2bc 100644
--- a/src/xercesc/util/regx/RegxUtil.cpp
+++ b/src/xercesc/util/regx/RegxUtil.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:42:55 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 15:17:00 tng
* C++ Namespace Support.
*
@@ -77,7 +80,7 @@
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/regx/RegxUtil.hpp>
-#include <xercesc/framework/XMLBuffer.hpp>
+#include <xercesc/util/XMLString.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -94,59 +97,60 @@ XMLCh* RegxUtil::decomposeToSurrogates(XMLInt32 ch) {
}
-XMLCh* RegxUtil::stripExtendedComment(const XMLCh* const expression) {
+XMLCh* RegxUtil::stripExtendedComment(const XMLCh* const expression,
+ MemoryManager* const manager) {
- unsigned int strLen = XMLString::stringLen(expression);
+ XMLCh* buffer = (manager) ? XMLString::replicate(expression)
+ : XMLString::replicate(expression, manager);
- if (strLen == 0)
- return 0;
+ if (buffer)
+ {
+ const XMLCh* inPtr = expression;
+ XMLCh* outPtr = buffer;
- XMLBuffer buffer;
- unsigned int offset = 0;
+ while (*inPtr) {
- while (offset < strLen) {
+ XMLCh ch = *inPtr++;
- XMLCh ch = expression[offset++];
+ if (ch == chFF || ch == chCR || ch == chLF
+ || ch == chSpace || ch == chHTab) {
+ continue;
+ }
- if (ch == chFF || ch == chCR || ch == chLF
- || ch == chSpace || ch == chHTab) {
- continue;
- }
+ // Skips chracters between '#' and a line end.
+ if (ch == chPound) {
- // Skips chracters between '#' and a line end.
- if (ch == chPound) {
+ while (*inPtr) {
- while (offset < strLen) {
+ ch = *inPtr++;
+ if (ch == chLF || ch == chCR)
+ break;
+ }
- ch = expression[offset++];
- if (ch == chLF || ch == chCR)
- break;
- }
- continue;
- }
+ continue;
+ }
- XMLCh next;
- if (ch == chBackSlash && offset < strLen) {
+ if (ch == chBackSlash && *inPtr) {
- if ((next = expression[offset]) == chPound
- || next == chHTab || next == chLF || next == chFF
- || next == chCR || next == chSpace) {
+ if ((ch = *inPtr++) == chPound || ch == chHTab || ch == chLF
+ || ch == chFF || ch == chCR || ch == chSpace) {
+ *outPtr++ = ch;
+ }
+ else { // Other escaped character.
- buffer.append(next);
- offset++;
- } else { // Other escaped character.
+ *outPtr++ = chBackSlash;
+ *outPtr++ = ch;
+ }
+ }
+ else { // As is.
+ *outPtr++ = ch;
+ }
+ }
- buffer.append(chBackSlash);
- buffer.append(next);
- offset++;
- }
- }
- else { // As is.
- buffer.append(ch);
- }
- }
+ *outPtr = chNull; // null terminate
+ }
- return XMLString::replicate(buffer.getRawBuffer());
+ return buffer;
}
XERCES_CPP_NAMESPACE_END
diff --git a/src/xercesc/util/regx/RegxUtil.hpp b/src/xercesc/util/regx/RegxUtil.hpp
index 9788a1836b74f3d8dc47afef7b2877b96bbe025f..973ede186d2d5b19ec1e82411e62f340a6339c7b 100644
--- a/src/xercesc/util/regx/RegxUtil.hpp
+++ b/src/xercesc/util/regx/RegxUtil.hpp
@@ -64,11 +64,13 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
+
XERCES_CPP_NAMESPACE_BEGIN
+class MemoryManager;
+
class XMLUTIL_EXPORT RegxUtil {
public:
@@ -83,7 +85,8 @@ public:
static bool isLowSurrogate(const XMLCh ch);
static bool isHighSurrogate(const XMLCh ch);
static XMLCh* decomposeToSurrogates(XMLInt32 ch);
- static XMLCh* stripExtendedComment(const XMLCh* const expression);
+ static XMLCh* stripExtendedComment(const XMLCh* const expression,
+ MemoryManager* const manager = 0);
private:
// -----------------------------------------------------------------------
diff --git a/src/xercesc/util/regx/Token.hpp b/src/xercesc/util/regx/Token.hpp
index 073f338ea1564b7aa6655840d51d73970321b643..169b040bf320aeeae37ea12dcc880bc1e64ff4ac 100644
--- a/src/xercesc/util/regx/Token.hpp
+++ b/src/xercesc/util/regx/Token.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -64,7 +64,6 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/util/RuntimeException.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -76,7 +75,8 @@ class RangeToken;
class TokenFactory;
-class XMLUTIL_EXPORT Token {
+class XMLUTIL_EXPORT Token : public XMemory
+{
public:
// -----------------------------------------------------------------------
// Public Constructors and Destructor
diff --git a/src/xercesc/util/regx/TokenFactory.hpp b/src/xercesc/util/regx/TokenFactory.hpp
index 1d53c24306b4bd7f375c3899807e75b7f13af69e..77818cabb700ba5185ee4e3c40371fbdbb02b6f2 100644
--- a/src/xercesc/util/regx/TokenFactory.hpp
+++ b/src/xercesc/util/regx/TokenFactory.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -64,8 +64,6 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XMLUniDefs.hpp>
-#include <xercesc/util/RefHashTableOf.hpp>
#include <xercesc/util/RefVectorOf.hpp>
#include <xercesc/util/regx/Token.hpp>
#include <xercesc/util/Mutexes.hpp>
@@ -85,7 +83,8 @@ class ParenToken;
class StringToken;
class UnionToken;
-class XMLUTIL_EXPORT TokenFactory {
+class XMLUTIL_EXPORT TokenFactory : public XMemory
+{
public:
// -----------------------------------------------------------------------
diff --git a/src/xercesc/validators/DTD/DTDAttDef.cpp b/src/xercesc/validators/DTD/DTDAttDef.cpp
index 65d4ceec882bb18b226d29785f66298b49902dc2..983bf9beb63e945b9ac1799bccf3059da6fe63fc 100644
--- a/src/xercesc/validators/DTD/DTDAttDef.cpp
+++ b/src/xercesc/validators/DTD/DTDAttDef.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:54:50 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:50:40 tng
* C++ Namespace Support.
*
@@ -104,7 +107,7 @@ DTDAttDef::DTDAttDef(const XMLCh* const attName
, fElemId(XMLElementDecl::fgInvalidElemId)
, fName(0)
{
- fName = XMLString::replicate(attName);
+ fName = XMLString::replicate(attName, getMemoryManager());
}
DTDAttDef::DTDAttDef( const XMLCh* const attName
@@ -117,12 +120,12 @@ DTDAttDef::DTDAttDef( const XMLCh* const attName
, fElemId(XMLElementDecl::fgInvalidElemId)
, fName(0)
{
- fName = XMLString::replicate(attName);
+ fName = XMLString::replicate(attName, getMemoryManager());
}
DTDAttDef::~DTDAttDef()
{
- delete [] fName;
+ getMemoryManager()->deallocate(fName); //delete [] fName;
}
@@ -131,8 +134,8 @@ DTDAttDef::~DTDAttDef()
// ---------------------------------------------------------------------------
void DTDAttDef::setName(const XMLCh* const newName)
{
- delete [] fName;
- fName = XMLString::replicate(newName);
+ getMemoryManager()->deallocate(fName); //delete [] fName;
+ fName = XMLString::replicate(newName, getMemoryManager());
}
XERCES_CPP_NAMESPACE_END
diff --git a/src/xercesc/validators/DTD/DTDAttDef.hpp b/src/xercesc/validators/DTD/DTDAttDef.hpp
index 0e76f04be2d4a31e5fa7484bc6575519c880ac68..4aa4822eba6342628680ff16a1509ae7b8936189 100644
--- a/src/xercesc/validators/DTD/DTDAttDef.hpp
+++ b/src/xercesc/validators/DTD/DTDAttDef.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:54:50 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2003/01/29 19:46:40 gareth
* added DOMTypeInfo API
*
@@ -82,7 +85,6 @@
#if !defined(DTDATTDEF_HPP)
#define DTDATTDEF_HPP
-#include <xercesc/util/XMLString.hpp>
#include <xercesc/framework/XMLAttDef.hpp>
XERCES_CPP_NAMESPACE_BEGIN
diff --git a/src/xercesc/validators/DTD/DTDElementDecl.cpp b/src/xercesc/validators/DTD/DTDElementDecl.cpp
index ca10c250d9cfa02eed7ab5cb7a738ce62c904287..1fe9e38519a3fc2a10a03fb3985d089110de6e6f 100644
--- a/src/xercesc/validators/DTD/DTDElementDecl.cpp
+++ b/src/xercesc/validators/DTD/DTDElementDecl.cpp
@@ -78,9 +78,10 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// DTDElementDecl: Constructors and Destructor
// ---------------------------------------------------------------------------
-DTDElementDecl::DTDElementDecl() :
+DTDElementDecl::DTDElementDecl(MemoryManager* const manager) :
- fAttDefs(0)
+ XMLElementDecl(manager)
+ , fAttDefs(0)
, fAttList(0)
, fContentSpec(0)
, fModelType(Any)
@@ -89,10 +90,12 @@ DTDElementDecl::DTDElementDecl() :
{
}
-DTDElementDecl::DTDElementDecl( const XMLCh* const elemRawName
- , const unsigned int uriId
- , const DTDElementDecl::ModelTypes type) :
- fAttDefs(0)
+DTDElementDecl::DTDElementDecl( const XMLCh* const elemRawName
+ , const unsigned int uriId
+ , const DTDElementDecl::ModelTypes type
+ , MemoryManager* const manager) :
+ XMLElementDecl(manager)
+ , fAttDefs(0)
, fAttList(0)
, fContentSpec(0)
, fModelType(type)
@@ -102,9 +105,11 @@ DTDElementDecl::DTDElementDecl( const XMLCh* const elemRawName
setElementName(elemRawName, uriId);
}
-DTDElementDecl::DTDElementDecl( QName* const elementName
- , const DTDElementDecl::ModelTypes type) :
- fAttDefs(0)
+DTDElementDecl::DTDElementDecl( QName* const elementName
+ , const DTDElementDecl::ModelTypes type
+ , MemoryManager* const manager) :
+ XMLElementDecl(manager)
+ , fAttDefs(0)
, fAttList(0)
, fContentSpec(0)
, fModelType(type)
@@ -120,7 +125,7 @@ DTDElementDecl::~DTDElementDecl()
delete fAttList;
delete fContentSpec;
delete fContentModel;
- delete [] fFormattedModel;
+ getMemoryManager()->deallocate(fFormattedModel);//delete [] fFormattedModel;
}
@@ -149,7 +154,7 @@ XMLAttDef* DTDElementDecl::findAttr(const XMLCh* const qName
faultInAttDefList();
// And add a default attribute for this name
- retVal = new DTDAttDef(qName);
+ retVal = new (getMemoryManager()) DTDAttDef(qName);
retVal->setElemId(getId());
fAttDefs->put((void*)retVal->getFullName(), retVal);
@@ -295,17 +300,16 @@ void DTDElementDecl::addAttDef(DTDAttDef* const toAdd)
// ---------------------------------------------------------------------------
// DTDElementDecl: Private helper methods
// ---------------------------------------------------------------------------
-XMLCh*
-DTDElementDecl::formatContentModel() const
+XMLCh* DTDElementDecl::formatContentModel() const
{
XMLCh* newValue = 0;
if (fModelType == Any)
{
- newValue = XMLString::replicate(XMLUni::fgAnyString);
+ newValue = XMLString::replicate(XMLUni::fgAnyString, getMemoryManager());
}
else if (fModelType == Empty)
{
- newValue = XMLString::replicate(XMLUni::fgEmptyString);
+ newValue = XMLString::replicate(XMLUni::fgEmptyString, getMemoryManager());
}
else
{
@@ -316,7 +320,7 @@ DTDElementDecl::formatContentModel() const
//
XMLBuffer bufFmt;
getContentSpec()->formatSpec(bufFmt);
- newValue = XMLString::replicate(bufFmt.getRawBuffer());
+ newValue = XMLString::replicate(bufFmt.getRawBuffer(), getMemoryManager());
}
return newValue;
}
@@ -330,7 +334,7 @@ XMLContentModel* DTDElementDecl::makeContentModel()
// Just create a mixel content model object. This type of
// content model is optimized for mixed content validation.
//
- cmRet = new MixedContentModel(true, this->getContentSpec());
+ cmRet = new (getMemoryManager()) MixedContentModel(true, this->getContentSpec());
}
else if (fModelType == Children)
{
@@ -375,7 +379,7 @@ XMLContentModel* DTDElementDecl::createChildModel()
if (specNode->getType() == ContentSpecNode::Leaf)
{
// Create a simple content model
- return new SimpleContentModel
+ return new (getMemoryManager()) SimpleContentModel
(
true
, specNode->getElement()
@@ -393,7 +397,7 @@ XMLContentModel* DTDElementDecl::createChildModel()
if ((specNode->getFirst()->getType() == ContentSpecNode::Leaf)
&& (specNode->getSecond()->getType() == ContentSpecNode::Leaf))
{
- return new SimpleContentModel
+ return new (getMemoryManager()) SimpleContentModel
(
true
, specNode->getFirst()->getElement()
@@ -413,7 +417,7 @@ XMLContentModel* DTDElementDecl::createChildModel()
//
if (specNode->getFirst()->getType() == ContentSpecNode::Leaf)
{
- return new SimpleContentModel
+ return new (getMemoryManager()) SimpleContentModel
(
true
, specNode->getFirst()->getElement()
@@ -428,14 +432,19 @@ XMLContentModel* DTDElementDecl::createChildModel()
}
// Its not any simple type of content, so create a DFA based content model
- return new DFAContentModel(true, this->getContentSpec());
+ return new (getMemoryManager()) DFAContentModel
+ (
+ true
+ , this->getContentSpec()
+ , getMemoryManager()
+ );
}
void DTDElementDecl::faultInAttDefList() const
{
// Use a hash modulus of 29 and tell it owns its elements
- ((DTDElementDecl*)this)->fAttDefs = new RefHashTableOf<DTDAttDef>(29, true);
+ ((DTDElementDecl*)this)->fAttDefs = new (getMemoryManager()) RefHashTableOf<DTDAttDef>(29, true);
}
XERCES_CPP_NAMESPACE_END
diff --git a/src/xercesc/validators/DTD/DTDElementDecl.hpp b/src/xercesc/validators/DTD/DTDElementDecl.hpp
index ffe3331e13cc651fc1670b9969a6a39fb08c9f7a..cb240c59866e9c6bd1e8d535718fbb11f47e37e9 100644
--- a/src/xercesc/validators/DTD/DTDElementDecl.hpp
+++ b/src/xercesc/validators/DTD/DTDElementDecl.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:54:50 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2003/01/29 19:46:40 gareth
* added DOMTypeInfo API
*
@@ -154,19 +157,19 @@ public :
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- DTDElementDecl();
-
+ DTDElementDecl(MemoryManager* const manager);
DTDElementDecl
(
- const XMLCh* const elemRawName
- , const unsigned int uriId
- , const ModelTypes modelType = Any
+ const XMLCh* const elemRawName
+ , const unsigned int uriId
+ , const ModelTypes modelType// = Any
+ , MemoryManager* const manager
);
-
DTDElementDecl
(
- QName* const elementName
- , const ModelTypes modelType = Any
+ QName* const elementName
+ , const ModelTypes modelType// = Any
+ , MemoryManager* const manager
);
~DTDElementDecl();
diff --git a/src/xercesc/validators/DTD/DTDGrammar.cpp b/src/xercesc/validators/DTD/DTDGrammar.cpp
index 6027f76165a9459dde4acf860b965b4b200a21b4..9acacb310e1da8eb591956d2f6681403fb170ed7 100644
--- a/src/xercesc/validators/DTD/DTDGrammar.cpp
+++ b/src/xercesc/validators/DTD/DTDGrammar.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:54:50 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2002/12/04 02:47:25 knoaman
* scanner re-organization.
*
@@ -95,8 +98,9 @@ XERCES_CPP_NAMESPACE_BEGIN
//---------------------------------------------------------------------------
// DTDGrammar: Constructors and Destructor
// ---------------------------------------------------------------------------
-DTDGrammar::DTDGrammar() :
- fElemDeclPool(0)
+DTDGrammar::DTDGrammar(MemoryManager* const manager) :
+ fMemoryManager(manager)
+ , fElemDeclPool(0)
, fElemNonDeclPool(0)
, fEntityDeclPool(0)
, fNotationDeclPool(0)
@@ -108,10 +112,10 @@ DTDGrammar::DTDGrammar() :
// <TBD> Investigate what the optimum values would be for the various
// pools.
//
- fElemDeclPool = new NameIdPool<DTDElementDecl>(109);
- fElemNonDeclPool = new NameIdPool<DTDElementDecl>(29);
- fEntityDeclPool = new NameIdPool<DTDEntityDecl>(109);
- fNotationDeclPool = new NameIdPool<XMLNotationDecl>(109);
+ fElemDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(109);
+ fElemNonDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(29);
+ fEntityDeclPool = new (fMemoryManager) NameIdPool<DTDEntityDecl>(109);
+ fNotationDeclPool = new (fMemoryManager) NameIdPool<XMLNotationDecl>(109);
//
// Call our own reset method. This lets us have the pool setup stuff
@@ -145,7 +149,13 @@ XMLElementDecl* DTDGrammar::findOrAddElemDecl (const unsigned int uriId
// if not, then add this in
if (!retVal)
{
- retVal = new DTDElementDecl(qName, uriId, DTDElementDecl::Any);
+ retVal = new (fMemoryManager) DTDElementDecl
+ (
+ qName
+ , uriId
+ , DTDElementDecl::Any
+ , fMemoryManager
+ );
const unsigned int elemId = fElemNonDeclPool->put(retVal);
retVal->setId(elemId);
wasAdded = true;
@@ -164,7 +174,13 @@ XMLElementDecl* DTDGrammar::putElemDecl (const unsigned int uriId
, unsigned int scope
, const bool notDeclared)
{
- DTDElementDecl* retVal = new DTDElementDecl(qName, uriId, DTDElementDecl::Any);
+ DTDElementDecl* retVal = new (fMemoryManager) DTDElementDecl
+ (
+ qName
+ , uriId
+ , DTDElementDecl::Any
+ , fMemoryManager
+ );
const unsigned int elemId = (notDeclared) ? fElemNonDeclPool->put(retVal)
: fElemDeclPool->put(retVal);
retVal->setId(elemId);
diff --git a/src/xercesc/validators/DTD/DTDGrammar.hpp b/src/xercesc/validators/DTD/DTDGrammar.hpp
index bb89f4cdbb33d34eba6f22590510e7337f9ce626..df52780389e3fbf41b46ab4cf9b945c48d59a9df 100644
--- a/src/xercesc/validators/DTD/DTDGrammar.hpp
+++ b/src/xercesc/validators/DTD/DTDGrammar.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:54:50 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/11/04 14:50:40 tng
* C++ Namespace Support.
*
@@ -117,7 +120,7 @@ public:
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- DTDGrammar();
+ DTDGrammar(MemoryManager* const manager);
virtual ~DTDGrammar();
@@ -268,12 +271,13 @@ private:
// or not. When using a cached grammar, no need for pre content
// validation.
// -----------------------------------------------------------------------
- NameIdPool<DTDElementDecl>* fElemDeclPool;
- NameIdPool<DTDElementDecl>* fElemNonDeclPool;
- NameIdPool<DTDEntityDecl>* fEntityDeclPool;
- NameIdPool<XMLNotationDecl>* fNotationDeclPool;
- unsigned int fRootElemId;
- bool fValidated;
+ MemoryManager* fMemoryManager;
+ NameIdPool<DTDElementDecl>* fElemDeclPool;
+ NameIdPool<DTDElementDecl>* fElemNonDeclPool;
+ NameIdPool<DTDEntityDecl>* fEntityDeclPool;
+ NameIdPool<XMLNotationDecl>* fNotationDeclPool;
+ unsigned int fRootElemId;
+ bool fValidated;
};
diff --git a/src/xercesc/validators/DTD/DTDScanner.cpp b/src/xercesc/validators/DTD/DTDScanner.cpp
index 4d6af413d7e2e6cbea11e5d05a9819990f457e7b..41d843972d894b38425aeea0b31bfd988ff6d7a1 100644
--- a/src/xercesc/validators/DTD/DTDScanner.cpp
+++ b/src/xercesc/validators/DTD/DTDScanner.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.25 2003/05/15 18:54:50 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.24 2003/03/10 15:28:07 tng
* XML1.0 Errata E38
*
@@ -247,12 +250,13 @@ XERCES_CPP_NAMESPACE_BEGIN
// a repetition suffix. If so, it creates a new correct rep node and wraps
// the pass node in it. Otherwise, it returns the previous node.
//
-static ContentSpecNode*
-makeRepNode(const XMLCh testCh, ContentSpecNode* const prevNode)
+static ContentSpecNode* makeRepNode(const XMLCh testCh,
+ ContentSpecNode* const prevNode,
+ MemoryManager* const manager)
{
if (testCh == chQuestion)
{
- return new ContentSpecNode
+ return new (manager) ContentSpecNode
(
ContentSpecNode::ZeroOrOne
, prevNode
@@ -261,7 +265,7 @@ makeRepNode(const XMLCh testCh, ContentSpecNode* const prevNode)
}
else if (testCh == chPlus)
{
- return new ContentSpecNode
+ return new (manager) ContentSpecNode
(
ContentSpecNode::OneOrMore
, prevNode
@@ -270,7 +274,7 @@ makeRepNode(const XMLCh testCh, ContentSpecNode* const prevNode)
}
else if (testCh == chAsterisk)
{
- return new ContentSpecNode
+ return new (manager) ContentSpecNode
(
ContentSpecNode::ZeroOrMore
, prevNode
@@ -285,8 +289,11 @@ makeRepNode(const XMLCh testCh, ContentSpecNode* const prevNode)
// ---------------------------------------------------------------------------
// DTDValidator: Constructors and Destructor
// ---------------------------------------------------------------------------
-DTDScanner::DTDScanner(DTDGrammar* dtdGrammar, DocTypeHandler* const docTypeHandler) :
- fDocTypeHandler(docTypeHandler)
+DTDScanner::DTDScanner( DTDGrammar* dtdGrammar
+ , DocTypeHandler* const docTypeHandler
+ , MemoryManager* const manager) :
+ fMemoryManager(manager)
+ , fDocTypeHandler(docTypeHandler)
, fDumAttDef(0)
, fDumElemDecl(0)
, fDumEntityDecl(0)
@@ -605,7 +612,7 @@ DTDScanner::scanAttDef(DTDElementDecl& parentElem, XMLBuffer& bufToUse)
// Use the dummy decl to parse into and set its name to the name we got
if (!fDumAttDef)
{
- fDumAttDef = new DTDAttDef;
+ fDumAttDef = new (fMemoryManager) DTDAttDef;
fDumAttDef->setId(fNextAttrId++);
}
fDumAttDef->setName(bufToUse.getRawBuffer());
@@ -617,7 +624,7 @@ DTDScanner::scanAttDef(DTDElementDecl& parentElem, XMLBuffer& bufToUse)
// It does not already exist so create a new one, give it the next
// available unique id, and add it
//
- decl = new DTDAttDef(bufToUse.getRawBuffer());
+ decl = new (fMemoryManager) DTDAttDef(bufToUse.getRawBuffer());
decl->setId(fNextAttrId++);
decl->setExternalAttDeclaration(isReadingExternalEntity());
parentElem.addAttDef(decl);
@@ -794,7 +801,13 @@ void DTDScanner::scanAttListDecl()
// it having been created because of an attlist. Later, if its
// declared, this will be updated.
//
- elemDecl = new DTDElementDecl(bbName.getRawBuffer(), fEmptyNamespaceId);
+ elemDecl = new (fMemoryManager) DTDElementDecl
+ (
+ bbName.getRawBuffer()
+ , fEmptyNamespaceId
+ , DTDElementDecl::Any
+ , fMemoryManager
+ );
elemDecl->setCreateReason(XMLElementDecl::AttList);
elemDecl->setExternalElemDeclaration(isReadingExternalEntity());
fDTDGrammar->putElemDecl((XMLElementDecl*) elemDecl);
@@ -1247,19 +1260,25 @@ DTDScanner::scanChildren(const DTDElementDecl& elemDecl, XMLBuffer& bufToUse)
XMLElementDecl* decl = fDTDGrammar->getElemDecl(fEmptyNamespaceId, 0, bufToUse.getRawBuffer(), Grammar::TOP_LEVEL_SCOPE);
if (!decl)
{
- decl = new DTDElementDecl(bufToUse.getRawBuffer(), fEmptyNamespaceId);
+ decl = new (fMemoryManager) DTDElementDecl
+ (
+ bufToUse.getRawBuffer()
+ , fEmptyNamespaceId
+ , DTDElementDecl::Any
+ , fMemoryManager
+ );
decl->setCreateReason(XMLElementDecl::InContentModel);
decl->setExternalElemDeclaration(isReadingExternalEntity());
fDTDGrammar->putElemDecl(decl);
}
- curNode = new ContentSpecNode(decl->getElementName());
+ curNode = new (fMemoryManager) ContentSpecNode(decl->getElementName());
// Check for a PE ref here, but don't require spaces
const bool gotSpaces = checkForPERef(false, false, true);
// Check for a repetition character after the leaf
const XMLCh repCh = fReaderMgr->peekNextChar();
- ContentSpecNode* tmpNode = makeRepNode(repCh, curNode);
+ ContentSpecNode* tmpNode = makeRepNode(repCh, curNode, fMemoryManager);
if (tmpNode != curNode)
{
if (gotSpaces)
@@ -1301,13 +1320,13 @@ DTDScanner::scanChildren(const DTDElementDecl& elemDecl, XMLBuffer& bufToUse)
if (opCh == chComma)
{
curType = ContentSpecNode::Sequence;
- headNode = new ContentSpecNode(curType, curNode, 0);
+ headNode = new (fMemoryManager) ContentSpecNode(curType, curNode, 0);
curNode = headNode;
}
else if (opCh == chPipe)
{
curType = ContentSpecNode::Choice;
- headNode = new ContentSpecNode(curType, curNode, 0);
+ headNode = new (fMemoryManager) ContentSpecNode(curType, curNode, 0);
curNode = headNode;
}
else
@@ -1417,17 +1436,23 @@ DTDScanner::scanChildren(const DTDElementDecl& elemDecl, XMLBuffer& bufToUse)
XMLElementDecl* decl = fDTDGrammar->getElemDecl(fEmptyNamespaceId, 0, bufToUse.getRawBuffer(), Grammar::TOP_LEVEL_SCOPE);
if (!decl)
{
- decl = new DTDElementDecl(bufToUse.getRawBuffer(), fEmptyNamespaceId);
+ decl = new (fMemoryManager) DTDElementDecl
+ (
+ bufToUse.getRawBuffer()
+ , fEmptyNamespaceId
+ , DTDElementDecl::Any
+ , fMemoryManager
+ );
decl->setCreateReason(XMLElementDecl::InContentModel);
decl->setExternalElemDeclaration(isReadingExternalEntity());
fDTDGrammar->putElemDecl(decl);
}
- ContentSpecNode* tmpLeaf = new ContentSpecNode(decl->getElementName());
+ ContentSpecNode* tmpLeaf = new (fMemoryManager) ContentSpecNode(decl->getElementName());
// Check for a repetition character after the leaf
const XMLCh repCh = fReaderMgr->peekNextChar();
- ContentSpecNode* tmpLeaf2 = makeRepNode(repCh, tmpLeaf);
+ ContentSpecNode* tmpLeaf2 = makeRepNode(repCh, tmpLeaf, fMemoryManager);
if (tmpLeaf != tmpLeaf2)
fReaderMgr->getNextChar();
@@ -1437,7 +1462,7 @@ DTDScanner::scanChildren(const DTDElementDecl& elemDecl, XMLBuffer& bufToUse)
// Make the new node the second node of the current node,
// and then make it the current node.
//
- ContentSpecNode* newCur = new ContentSpecNode
+ ContentSpecNode* newCur = new (fMemoryManager) ContentSpecNode
(
curType
, tmpLeaf2
@@ -1475,7 +1500,7 @@ DTDScanner::scanChildren(const DTDElementDecl& elemDecl, XMLBuffer& bufToUse)
// of it.
//
XMLCh repCh = fReaderMgr->peekNextChar();
- ContentSpecNode* retNode = makeRepNode(repCh, headNode);
+ ContentSpecNode* retNode = makeRepNode(repCh, headNode, fMemoryManager);
if (retNode != headNode)
fReaderMgr->getNextChar();
@@ -1767,7 +1792,13 @@ void DTDScanner::scanElementDecl()
fScanner->getValidator()->emitError(XMLValid::ElementAlreadyExists, bbName.getRawBuffer());
if (!fDumElemDecl)
- fDumElemDecl = new DTDElementDecl(bbName.getRawBuffer(), fEmptyNamespaceId);
+ fDumElemDecl = new (fMemoryManager) DTDElementDecl
+ (
+ bbName.getRawBuffer()
+ , fEmptyNamespaceId
+ , DTDElementDecl::Any
+ , fMemoryManager
+ );
else
fDumElemDecl->setElementName(bbName.getRawBuffer(),fEmptyNamespaceId);
}
@@ -1778,7 +1809,13 @@ void DTDScanner::scanElementDecl()
// Create the new empty declaration to fill in and put it into
// the decl pool.
//
- decl = new DTDElementDecl(bbName.getRawBuffer(), fEmptyNamespaceId);
+ decl = new (fMemoryManager) DTDElementDecl
+ (
+ bbName.getRawBuffer()
+ , fEmptyNamespaceId
+ , DTDElementDecl::Any
+ , fMemoryManager
+ );
fDTDGrammar->putElemDecl(decl);
}
@@ -1887,14 +1924,14 @@ void DTDScanner::scanEntityDecl()
if (entityDecl)
{
if (!fDumEntityDecl)
- fDumEntityDecl = new DTDEntityDecl;
+ fDumEntityDecl = new (fMemoryManager) DTDEntityDecl;
fDumEntityDecl->setName(bbName.getRawBuffer());
entityDecl = fDumEntityDecl;
}
else
{
// Its not in existence already, then create an entity decl for it
- entityDecl = new DTDEntityDecl(bbName.getRawBuffer());
+ entityDecl = new (fMemoryManager) DTDEntityDecl(bbName.getRawBuffer());
//
// Set the declaration location. The parameter indicates whether its
@@ -3269,7 +3306,7 @@ bool DTDScanner::scanMixed(DTDElementDecl& toFill)
// tree as we go.
//
ContentSpecNode* curNode =
- new ContentSpecNode(new QName(XMLUni::fgZeroLenString,
+ new (fMemoryManager) ContentSpecNode(new (fMemoryManager) QName(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
XMLElementDecl::fgPCDataElemId),
false);
@@ -3339,7 +3376,7 @@ bool DTDScanner::scanMixed(DTDElementDecl& toFill)
// node its first child.
//
if (starRequired || starSkipped) {
- headNode = new ContentSpecNode
+ headNode = new (fMemoryManager) ContentSpecNode
(
ContentSpecNode::ZeroOrMore
, headNode
@@ -3374,7 +3411,13 @@ bool DTDScanner::scanMixed(DTDElementDecl& toFill)
XMLElementDecl* decl = fDTDGrammar->getElemDecl(fEmptyNamespaceId, 0, nameBuf.getRawBuffer(), Grammar::TOP_LEVEL_SCOPE);
if (!decl)
{
- decl = new DTDElementDecl(nameBuf.getRawBuffer(), fEmptyNamespaceId);
+ decl = new (fMemoryManager) DTDElementDecl
+ (
+ nameBuf.getRawBuffer()
+ , fEmptyNamespaceId
+ , DTDElementDecl::Any
+ , fMemoryManager
+ );
decl->setCreateReason(XMLElementDecl::InContentModel);
decl->setExternalElemDeclaration(isReadingExternalEntity());
fDTDGrammar->putElemDecl(decl);
@@ -3391,11 +3434,11 @@ bool DTDScanner::scanMixed(DTDElementDecl& toFill)
//
if (curNode == orgNode)
{
- curNode = new ContentSpecNode
+ curNode = new (fMemoryManager) ContentSpecNode
(
ContentSpecNode::Choice
, curNode
- , new ContentSpecNode(decl->getElementName())
+ , new (fMemoryManager) ContentSpecNode(decl->getElementName())
);
// Remember the top node
@@ -3406,11 +3449,11 @@ bool DTDScanner::scanMixed(DTDElementDecl& toFill)
ContentSpecNode* oldRight = curNode->orphanSecond();
curNode->setSecond
(
- new ContentSpecNode
+ new (fMemoryManager) ContentSpecNode
(
ContentSpecNode::Choice
, oldRight
- , new ContentSpecNode(decl->getElementName())
+ , new (fMemoryManager) ContentSpecNode(decl->getElementName())
)
);
@@ -3500,7 +3543,7 @@ void DTDScanner::scanNotationDecl()
ReaderMgr::LastExtEntityInfo lastInfo;
fReaderMgr->getLastExtEntityInfo(lastInfo);
- decl = new XMLNotationDecl
+ decl = new (fMemoryManager) XMLNotationDecl
(
bbName.getRawBuffer()
, (publicId && *publicId) ? publicId : 0
diff --git a/src/xercesc/validators/DTD/DTDScanner.hpp b/src/xercesc/validators/DTD/DTDScanner.hpp
index d05a371a4119d1160ba787f327b8dd98fbf08623..1f15b87cbd998995b8e6d3c993c578f0c4466afb 100644
--- a/src/xercesc/validators/DTD/DTDScanner.hpp
+++ b/src/xercesc/validators/DTD/DTDScanner.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 1999-2001 The Apache Software Foundation. All rights
+ * Copyright (c) 1999-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2003/05/15 18:54:51 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.6 2003/02/05 22:07:09 tng
* [Bug 3111] Problem with LexicalHandler::startDTD() and LexicalHandler::endDTD().
*
@@ -105,7 +108,7 @@ class XMLScanner;
*/
class DocTypeHandler;
-class VALIDATORS_EXPORT DTDScanner
+class VALIDATORS_EXPORT DTDScanner : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -137,7 +140,12 @@ public:
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- DTDScanner(DTDGrammar* dtdGrammar, DocTypeHandler* const docTypeHandler);
+ DTDScanner
+ (
+ DTDGrammar* dtdGrammar
+ , DocTypeHandler* const docTypeHandler
+ , MemoryManager* const manager
+ );
virtual ~DTDScanner();
// -----------------------------------------------------------------------
@@ -286,6 +294,7 @@ private:
// current reader to decide whether we are processing an external/internal
// declaration
// -----------------------------------------------------------------------
+ MemoryManager* fMemoryManager;
DocTypeHandler* fDocTypeHandler;
DTDAttDef* fDumAttDef;
DTDElementDecl* fDumElemDecl;
diff --git a/src/xercesc/validators/common/AllContentModel.cpp b/src/xercesc/validators/common/AllContentModel.cpp
index 33b2ad84434edca565b03c45d6d468997e04961e..0477174302f3dcf15ddcc699e488e5d182e856eb 100644
--- a/src/xercesc/validators/common/AllContentModel.cpp
+++ b/src/xercesc/validators/common/AllContentModel.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -93,9 +96,11 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// AllContentModel: Constructors and Destructor
// ---------------------------------------------------------------------------
-AllContentModel::AllContentModel(ContentSpecNode* const parentContentSpec
- , const bool isMixed) :
- fCount(0)
+AllContentModel::AllContentModel( ContentSpecNode* const parentContentSpec
+ , const bool isMixed
+ , MemoryManager* const manager) :
+ fMemoryManager(manager)
+ , fCount(0)
, fChildren(0)
, fChildOptional(0)
, fNumRequired(0)
@@ -128,8 +133,8 @@ AllContentModel::AllContentModel(ContentSpecNode* const parentContentSpec
// fill them in.
//
fCount = children.size();
- fChildren = new QName*[fCount];
- fChildOptional = new bool[fCount];
+ fChildren = (QName**) fMemoryManager->allocate(fCount * sizeof(QName*)); //new QName*[fCount];
+ fChildOptional = (bool*) fMemoryManager->allocate(fCount * sizeof(bool)); //new bool[fCount];
for (unsigned int index = 0; index < fCount; index++) {
fChildren[index] = children.elementAt(index);
fChildOptional[index] = childOptional.elementAt(index);
@@ -138,8 +143,8 @@ AllContentModel::AllContentModel(ContentSpecNode* const parentContentSpec
AllContentModel::~AllContentModel()
{
- delete [] fChildren;
- delete [] fChildOptional;
+ fMemoryManager->deallocate(fChildren); //delete [] fChildren;
+ fMemoryManager->deallocate(fChildOptional); //delete [] fChildOptional;
}
// ---------------------------------------------------------------------------
@@ -162,7 +167,7 @@ AllContentModel::validateContent( QName** const children
return -1;
// Check for duplicate element
- bool* elementSeen = new bool[fCount];
+ bool* elementSeen = (bool*) fMemoryManager->allocate(fCount*sizeof(bool)); //new bool[fCount];
// initialize the array
for (unsigned int i = 0; i < fCount; i++)
@@ -190,7 +195,7 @@ AllContentModel::validateContent( QName** const children
// If this element was seen already, indicate an error was
// found at the duplicate index.
if (elementSeen[inIndex]) {
- delete [] elementSeen;
+ fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
return outIndex;
}
else
@@ -205,13 +210,13 @@ AllContentModel::validateContent( QName** const children
// We did not find this one, so the validation failed
if (inIndex == fCount) {
- delete [] elementSeen;
+ fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
return outIndex;
}
}
- delete [] elementSeen;
+ fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
// Were all the required elements of the <all> encountered?
if (numRequiredSeen != fNumRequired) {
@@ -239,7 +244,7 @@ int AllContentModel::validateContentSpecial(QName** const children
return -1;
// Check for duplicate element
- bool* elementSeen = new bool[fCount];
+ bool* elementSeen = (bool*) fMemoryManager->allocate(fCount*sizeof(bool)); //new bool[fCount];
// initialize the array
for (unsigned int i = 0; i < fCount; i++)
@@ -266,7 +271,7 @@ int AllContentModel::validateContentSpecial(QName** const children
// If this element was seen already, indicate an error was
// found at the duplicate index.
if (elementSeen[inIndex]) {
- delete [] elementSeen;
+ fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
return outIndex;
}
else
@@ -281,13 +286,13 @@ int AllContentModel::validateContentSpecial(QName** const children
// We did not find this one, so the validation failed
if (inIndex == fCount) {
- delete [] elementSeen;
+ fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
return outIndex;
}
}
- delete [] elementSeen;
+ fMemoryManager->deallocate(elementSeen); //delete [] elementSeen;
// Were all the required elements of the <all> encountered?
if (numRequiredSeen != fNumRequired) {
diff --git a/src/xercesc/validators/common/AllContentModel.hpp b/src/xercesc/validators/common/AllContentModel.hpp
index 337614ba0998421590bc4bcfe339e5e2f51131a1..0730bd3790a482d7351659e2c2351c4f87e6cc47 100644
--- a/src/xercesc/validators/common/AllContentModel.hpp
+++ b/src/xercesc/validators/common/AllContentModel.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2003/03/07 18:16:57 tng
* Return a reference instead of void for operator=
*
@@ -77,8 +80,8 @@
#if !defined(ALLCONTENTMODEL_HPP)
#define ALLCONTENTMODEL_HPP
-#include <xercesc/util/ValueVectorOf.hpp>
#include <xercesc/framework/XMLContentModel.hpp>
+#include <xercesc/util/ValueVectorOf.hpp>
#include <xercesc/validators/common/ContentLeafNameTypeVector.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -102,8 +105,9 @@ public :
// -----------------------------------------------------------------------
AllContentModel
(
- ContentSpecNode* const parentContentSpec
- , const bool isMixed
+ ContentSpecNode* const parentContentSpec
+ , const bool isMixed
+ , MemoryManager* const manager
);
~AllContentModel();
@@ -180,6 +184,7 @@ private :
// fIsMixed
// AllContentModel with mixed PCDATA.
// -----------------------------------------------------------------------
+ MemoryManager* fMemoryManager;
unsigned int fCount;
QName** fChildren;
bool* fChildOptional;
diff --git a/src/xercesc/validators/common/CMAny.cpp b/src/xercesc/validators/common/CMAny.cpp
index 3224ed4b5d99860a28c85505b0bb3a37c51b2d17..4dcea5d99f75052bccb13b8b10e78b26b91d9058 100644
--- a/src/xercesc/validators/common/CMAny.cpp
+++ b/src/xercesc/validators/common/CMAny.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -95,10 +98,11 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// CMUnaryOp: Constructors and Destructor
// ---------------------------------------------------------------------------
-CMAny::CMAny( const ContentSpecNode::NodeTypes type
- , const unsigned int URI
- , const unsigned int position ) :
- CMNode(type)
+CMAny::CMAny( const ContentSpecNode::NodeTypes type
+ , const unsigned int URI
+ , const unsigned int position
+ , MemoryManager* const manager) :
+ CMNode(type, manager)
, fURI(URI)
, fPosition(position)
{
diff --git a/src/xercesc/validators/common/CMAny.hpp b/src/xercesc/validators/common/CMAny.hpp
index 44bdb6899dcfd696615c6c4e33a0fd67e54e8954..d61bad7200cd8868b30373e80cfcfba8a90602b4 100644
--- a/src/xercesc/validators/common/CMAny.hpp
+++ b/src/xercesc/validators/common/CMAny.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -73,7 +76,6 @@
#if !defined(CMANY_HPP)
#define CMANY_HPP
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/validators/common/CMNode.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -88,9 +90,10 @@ public :
// -----------------------------------------------------------------------
CMAny
(
- const ContentSpecNode::NodeTypes type
- , const unsigned int URI
- , const unsigned int position
+ const ContentSpecNode::NodeTypes type
+ , const unsigned int URI
+ , const unsigned int position
+ , MemoryManager* const manager
);
~CMAny();
diff --git a/src/xercesc/validators/common/CMBinaryOp.cpp b/src/xercesc/validators/common/CMBinaryOp.cpp
index 3f9e5ff42b37e354ff3ea1af10d15e0f56c21052..1b362a5748effb71ae2a3defd2768a029ff13dde 100644
--- a/src/xercesc/validators/common/CMBinaryOp.cpp
+++ b/src/xercesc/validators/common/CMBinaryOp.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -104,10 +107,11 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// CMBinaryOp: Constructors
// ---------------------------------------------------------------------------
-CMBinaryOp::CMBinaryOp( const ContentSpecNode::NodeTypes type
- , CMNode* const leftToAdopt
- , CMNode* const rightToAdopt) :
- CMNode(type)
+CMBinaryOp::CMBinaryOp( const ContentSpecNode::NodeTypes type
+ , CMNode* const leftToAdopt
+ , CMNode* const rightToAdopt
+ , MemoryManager* const manager) :
+ CMNode(type, manager)
, fLeftChild(leftToAdopt)
, fRightChild(rightToAdopt)
{
diff --git a/src/xercesc/validators/common/CMBinaryOp.hpp b/src/xercesc/validators/common/CMBinaryOp.hpp
index 72fd139b31bb50e176f59618f42593a931f6b230..1eff593ea26fc23dd0b3349e5673fb3f6fbfd02b 100644
--- a/src/xercesc/validators/common/CMBinaryOp.hpp
+++ b/src/xercesc/validators/common/CMBinaryOp.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -95,7 +98,6 @@
#if !defined(CMBINARYOP_HPP)
#define CMBINARYOP_HPP
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/validators/common/CMNode.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -110,9 +112,10 @@ public :
// -----------------------------------------------------------------------
CMBinaryOp
(
- const ContentSpecNode::NodeTypes type
- , CMNode* const leftToAdopt
- , CMNode* const rightToAdopt
+ const ContentSpecNode::NodeTypes type
+ , CMNode* const leftToAdopt
+ , CMNode* const rightToAdopt
+ , MemoryManager* const manager
);
~CMBinaryOp();
diff --git a/src/xercesc/validators/common/CMLeaf.hpp b/src/xercesc/validators/common/CMLeaf.hpp
index b334d6b960d90532e0557b65ada4d40faf1bd28b..061323db9a951578bbcc45915e420ae670098df5 100644
--- a/src/xercesc/validators/common/CMLeaf.hpp
+++ b/src/xercesc/validators/common/CMLeaf.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -114,11 +117,8 @@
#if !defined(CMLEAF_HPP)
#define CMLEAF_HPP
-#include <xercesc/util/XercesDefs.hpp>
-#include <xercesc/util/RuntimeException.hpp>
-#include <xercesc/validators/common/ContentSpecNode.hpp>
#include <xercesc/validators/common/CMNode.hpp>
-#include <xercesc/validators/common/CMStateSet.hpp>
+
XERCES_CPP_NAMESPACE_BEGIN
@@ -135,14 +135,16 @@ public :
// -----------------------------------------------------------------------
CMLeaf
(
- QName* const element
- , const unsigned int position = ~0
+ QName* const element
+ , const unsigned int position = ~0
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
);
CMLeaf
(
- QName* const element
- , const unsigned int position
- , const bool adopt
+ QName* const element
+ , const unsigned int position
+ , const bool adopt
+ , MemoryManager* const manager
);
~CMLeaf();
@@ -199,18 +201,22 @@ private :
// -----------------------------------------------------------------------
// Constructors
// -----------------------------------------------------------------------
-inline CMLeaf::CMLeaf( QName* const element
- , const unsigned int position) :
- CMNode(ContentSpecNode::Leaf)
+inline CMLeaf::CMLeaf( QName* const element
+ , const unsigned int position
+ , MemoryManager* const manager) :
+ CMNode(ContentSpecNode::Leaf, manager)
, fElement(0)
, fPosition(position)
, fAdopt(false)
{
if (!element)
{
- fElement = new QName(XMLUni::fgZeroLenString
- , XMLUni::fgZeroLenString
- , XMLElementDecl::fgInvalidElemId);
+ fElement = new (fMemoryManager) QName
+ (
+ XMLUni::fgZeroLenString
+ , XMLUni::fgZeroLenString
+ , XMLElementDecl::fgInvalidElemId
+ );
// We have to be responsible for this QName - override default fAdopt
fAdopt = true;
}
@@ -220,19 +226,23 @@ inline CMLeaf::CMLeaf( QName* const element
}
}
-inline CMLeaf::CMLeaf( QName* const element
- , const unsigned int position
- , const bool adopt) :
- CMNode(ContentSpecNode::Leaf)
+inline CMLeaf::CMLeaf( QName* const element
+ , const unsigned int position
+ , const bool adopt
+ , MemoryManager* const manager) :
+ CMNode(ContentSpecNode::Leaf, manager)
, fElement(0)
, fPosition(position)
, fAdopt(adopt)
{
if (!element)
{
- fElement = new QName(XMLUni::fgZeroLenString
- , XMLUni::fgZeroLenString
- , XMLElementDecl::fgInvalidElemId);
+ fElement = new (fMemoryManager) QName
+ (
+ XMLUni::fgZeroLenString
+ , XMLUni::fgZeroLenString
+ , XMLElementDecl::fgInvalidElemId
+ );
// We have to be responsible for this QName - override adopt parameter
fAdopt = true;
}
diff --git a/src/xercesc/validators/common/CMNode.hpp b/src/xercesc/validators/common/CMNode.hpp
index a643da653fd55d98104496bfeb787bf167f69373..2d5d656e062c44e58ddf1f55afebddaf4daeeff6 100644
--- a/src/xercesc/validators/common/CMNode.hpp
+++ b/src/xercesc/validators/common/CMNode.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2003/03/07 18:16:57 tng
* Return a reference instead of void for operator=
*
@@ -102,19 +105,22 @@
#if !defined(CMNODE_HPP)
#define CMNODE_HPP
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/validators/common/ContentSpecNode.hpp>
#include <xercesc/validators/common/CMStateSet.hpp>
XERCES_CPP_NAMESPACE_BEGIN
-class CMNode
+class CMNode : public XMemory
{
public :
// -----------------------------------------------------------------------
// Constructors and Destructors
// -----------------------------------------------------------------------
- CMNode(const ContentSpecNode::NodeTypes type);
+ CMNode
+ (
+ const ContentSpecNode::NodeTypes type
+ , MemoryManager* const manager
+ );
virtual ~CMNode();
@@ -145,6 +151,14 @@ protected :
virtual void calcFirstPos(CMStateSet& toUpdate) const = 0;
virtual void calcLastPos(CMStateSet& toUpdate) const = 0;
+ // -----------------------------------------------------------------------
+ // Protected data members
+ //
+ // fMemoryManager
+ // Pluggable memory manager for dynamic allocation/deallocation.
+ // -----------------------------------------------------------------------
+ MemoryManager* fMemoryManager;
+
private :
// -----------------------------------------------------------------------
@@ -177,10 +191,10 @@ private :
// has to be stored redundantly, but we need to fault in the
// state set members and they have to be sized to this size.
// -----------------------------------------------------------------------
- ContentSpecNode::NodeTypes fType;
- CMStateSet* fFirstPos;
- CMStateSet* fLastPos;
- unsigned int fMaxStates;
+ ContentSpecNode::NodeTypes fType;
+ CMStateSet* fFirstPos;
+ CMStateSet* fLastPos;
+ unsigned int fMaxStates;
};
@@ -188,9 +202,11 @@ private :
// ---------------------------------------------------------------------------
// CMNode: Constructors and Destructors
// ---------------------------------------------------------------------------
-inline CMNode::CMNode(const ContentSpecNode::NodeTypes type) :
+inline CMNode::CMNode(const ContentSpecNode::NodeTypes type,
+ MemoryManager* const manager) :
- fType(type)
+ fMemoryManager(manager)
+ , fType(type)
, fFirstPos(0)
, fLastPos(0)
, fMaxStates(~0)
@@ -222,7 +238,7 @@ inline const CMStateSet& CMNode::getFirstPos() const
if (!fFirstPos)
{
CMNode* unconstThis = (CMNode*)this;
- unconstThis->fFirstPos = new CMStateSet(fMaxStates);
+ unconstThis->fFirstPos = new (fMemoryManager) CMStateSet(fMaxStates, fMemoryManager);
unconstThis->calcFirstPos(*fFirstPos);
}
return *fFirstPos;
@@ -237,7 +253,7 @@ inline const CMStateSet& CMNode::getLastPos() const
if (!fLastPos)
{
CMNode* unconstThis = (CMNode*)this;
- unconstThis->fLastPos = new CMStateSet(fMaxStates);
+ unconstThis->fLastPos = new (fMemoryManager) CMStateSet(fMaxStates, fMemoryManager);
unconstThis->calcLastPos(*fLastPos);
}
return *fLastPos;
diff --git a/src/xercesc/validators/common/CMStateSet.hpp b/src/xercesc/validators/common/CMStateSet.hpp
index 76e14c6decdfc943e578aa21a8789a4dacea0710..51aaf59010fce7af6fe9fb98109a5feaef296933 100644
--- a/src/xercesc/validators/common/CMStateSet.hpp
+++ b/src/xercesc/validators/common/CMStateSet.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -112,23 +115,25 @@
#if !defined(CMSTATESET_HPP)
#define CMSTATESET_HPP
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/util/ArrayIndexOutOfBoundsException.hpp>
-#include <xercesc/framework/XMLValidityCodes.hpp>
+#include <xercesc/util/RuntimeException.hpp>
+#include <xercesc/framework/MemoryManager.hpp>
#include <string.h>
XERCES_CPP_NAMESPACE_BEGIN
-class CMStateSet
+class CMStateSet : public XMemory
{
public :
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- CMStateSet(const unsigned int bitCount) :
+ CMStateSet( const unsigned int bitCount
+ , MemoryManager* const manager) :
fBitCount(bitCount)
, fByteArray(0)
+ , fMemoryManager(manager)
{
//
// See if we need to allocate the byte array or whether we can live
@@ -139,7 +144,7 @@ public :
fByteCount = fBitCount / 8;
if (fBitCount % 8)
fByteCount++;
- fByteArray = new XMLByte[fByteCount];
+ fByteArray = (XMLByte*) fMemoryManager->allocate(fByteCount*sizeof(XMLByte)); //new XMLByte[fByteCount];
}
// Init all the bits to zero
@@ -157,6 +162,7 @@ public :
CMStateSet(const CMStateSet& toCopy) :
fBitCount(toCopy.fBitCount)
, fByteArray(0)
+ , fMemoryManager(toCopy.fMemoryManager)
{
//
// See if we need to allocate the byte array or whether we can live
@@ -167,7 +173,7 @@ public :
fByteCount = fBitCount / 8;
if (fBitCount % 8)
fByteCount++;
- fByteArray = new XMLByte[fByteCount];
+ fByteArray = (XMLByte*) fMemoryManager->allocate(fByteCount*sizeof(XMLByte)); //new XMLByte[fByteCount];
memcpy((void *) fByteArray,
(const void *) toCopy.fByteArray,
@@ -186,7 +192,7 @@ public :
~CMStateSet()
{
if (fByteArray)
- delete [] fByteArray;
+ fMemoryManager->deallocate(fByteArray); //delete [] fByteArray;
}
@@ -392,6 +398,7 @@ private :
unsigned int fBits1;
unsigned int fBits2;
XMLByte* fByteArray;
+ MemoryManager* fMemoryManager;
};
XERCES_CPP_NAMESPACE_END
diff --git a/src/xercesc/validators/common/CMUnaryOp.cpp b/src/xercesc/validators/common/CMUnaryOp.cpp
index 55ccfa2ad532fe3a57a555bf762d711ecd9809fa..6e15649df40743f4c38eadef3fc5c0a65292821c 100644
--- a/src/xercesc/validators/common/CMUnaryOp.cpp
+++ b/src/xercesc/validators/common/CMUnaryOp.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -96,7 +99,6 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/util/RuntimeException.hpp>
#include <xercesc/validators/common/CMStateSet.hpp>
#include <xercesc/validators/common/CMUnaryOp.hpp>
@@ -106,9 +108,10 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// CMUnaryOp: Constructors and Destructor
// ---------------------------------------------------------------------------
-CMUnaryOp::CMUnaryOp( const ContentSpecNode::NodeTypes type
- , CMNode* const nodeToAdopt) :
- CMNode(type)
+CMUnaryOp::CMUnaryOp( const ContentSpecNode::NodeTypes type
+ , CMNode* const nodeToAdopt
+ , MemoryManager* const manager) :
+ CMNode(type, manager)
, fChild(nodeToAdopt)
{
// Insure that its one of the types we require
diff --git a/src/xercesc/validators/common/CMUnaryOp.hpp b/src/xercesc/validators/common/CMUnaryOp.hpp
index ca7b0b12e0aa937126300533cc4409dfe4b82cf5..b7bf2e83233445ee74ed12e3904d655859d0f93c 100644
--- a/src/xercesc/validators/common/CMUnaryOp.hpp
+++ b/src/xercesc/validators/common/CMUnaryOp.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -96,9 +99,8 @@
#if !defined(CMUNARYOP_HPP)
#define CMUNARYOP_HPP
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/validators/common/CMNode.hpp>
-#include <xercesc/validators/common/ContentSpecNode.hpp>
+
XERCES_CPP_NAMESPACE_BEGIN
@@ -112,8 +114,9 @@ public :
// -----------------------------------------------------------------------
CMUnaryOp
(
- const ContentSpecNode::NodeTypes type
- , CMNode* const nodeToAdopt
+ const ContentSpecNode::NodeTypes type
+ , CMNode* const nodeToAdopt
+ , MemoryManager* const manager
);
~CMUnaryOp();
diff --git a/src/xercesc/validators/common/ContentLeafNameTypeVector.cpp b/src/xercesc/validators/common/ContentLeafNameTypeVector.cpp
index a8b235473a5957d8c6352db1259ad9af2e0d6b75..ca46f5002708d4a14ad25501bf733cb4eccf7fbc 100644
--- a/src/xercesc/validators/common/ContentLeafNameTypeVector.cpp
+++ b/src/xercesc/validators/common/ContentLeafNameTypeVector.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -77,7 +80,6 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/validators/common/ContentLeafNameTypeVector.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -85,19 +87,26 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// ContentLeafNameTypeVector: Constructors and Destructor
// ---------------------------------------------------------------------------
-ContentLeafNameTypeVector::ContentLeafNameTypeVector()
-: fLeafNames(0)
+ContentLeafNameTypeVector::ContentLeafNameTypeVector
+(
+ MemoryManager* const manager
+)
+: fMemoryManager(manager)
+, fLeafNames(0)
, fLeafTypes(0)
, fLeafCount(0)
{
}
ContentLeafNameTypeVector::ContentLeafNameTypeVector
- ( QName** const names
- , ContentSpecNode::NodeTypes* const types
- , const unsigned int count
- )
-: fLeafNames(0)
+(
+ QName** const names
+ , ContentSpecNode::NodeTypes* const types
+ , const unsigned int count
+ , MemoryManager* const manager
+)
+: fMemoryManager(manager)
+, fLeafNames(0)
, fLeafTypes(0)
, fLeafCount(0)
{
@@ -108,10 +117,13 @@ ContentLeafNameTypeVector::ContentLeafNameTypeVector
copy ctor
***/
ContentLeafNameTypeVector::ContentLeafNameTypeVector
- (const ContentLeafNameTypeVector& toCopy)
- :fLeafNames(0)
- ,fLeafTypes(0)
- ,fLeafCount(0)
+(
+ const ContentLeafNameTypeVector& toCopy
+)
+: fMemoryManager(toCopy.fMemoryManager)
+, fLeafNames(0)
+, fLeafTypes(0)
+, fLeafCount(0)
{
fLeafCount=toCopy.getLeafCount();
init(fLeafCount);
diff --git a/src/xercesc/validators/common/ContentLeafNameTypeVector.hpp b/src/xercesc/validators/common/ContentLeafNameTypeVector.hpp
index e08b76333c38bfac9677e2f913fd7106653a88a8..b465582701f149833b0f4d05c529423c138076e9 100644
--- a/src/xercesc/validators/common/ContentLeafNameTypeVector.hpp
+++ b/src/xercesc/validators/common/ContentLeafNameTypeVector.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2003/03/07 18:16:57 tng
* Return a reference instead of void for operator=
*
@@ -83,13 +86,12 @@
#if !defined(CONTENTLEAFNAMETYPEVECTOR_HPP)
#define CONTENTLEAFNAMETYPEVECTOR_HPP
-#include <xercesc/util/XercesDefs.hpp>
-#include <xercesc/util/ValueVectorOf.hpp>
#include <xercesc/validators/common/ContentSpecNode.hpp>
+#include <xercesc/framework/MemoryManager.hpp>
XERCES_CPP_NAMESPACE_BEGIN
-class ContentLeafNameTypeVector
+class ContentLeafNameTypeVector : public XMemory
{
public :
// -----------------------------------------------------------------------
@@ -100,12 +102,13 @@ public :
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- ContentLeafNameTypeVector();
+ ContentLeafNameTypeVector(MemoryManager* const manager);
ContentLeafNameTypeVector
(
- QName** const qName
- , ContentSpecNode::NodeTypes* const types
- , const unsigned int count
+ QName** const qName
+ , ContentSpecNode::NodeTypes* const types
+ , const unsigned int count
+ , MemoryManager* const manager
);
~ContentLeafNameTypeVector();
@@ -150,6 +153,7 @@ private :
// Private Data Members
//
// -----------------------------------------------------------------------
+ MemoryManager* fMemoryManager;
QName** fLeafNames;
ContentSpecNode::NodeTypes *fLeafTypes;
unsigned int fLeafCount;
@@ -157,15 +161,18 @@ private :
inline void ContentLeafNameTypeVector::cleanUp()
{
- delete [] fLeafNames;
- delete [] fLeafTypes;
+ fMemoryManager->deallocate(fLeafNames); //delete [] fLeafNames;
+ fMemoryManager->deallocate(fLeafTypes); //delete [] fLeafTypes;
}
inline void ContentLeafNameTypeVector::init(const unsigned int size)
{
- fLeafNames = new QName*[size];
- fLeafTypes = new ContentSpecNode::NodeTypes [size];
- fLeafCount = size;
+ fLeafNames = (QName**) fMemoryManager->allocate(size * sizeof(QName*));//new QName*[size];
+ fLeafTypes = (ContentSpecNode::NodeTypes *) fMemoryManager->allocate
+ (
+ size * sizeof(ContentSpecNode::NodeTypes)
+ ); //new ContentSpecNode::NodeTypes [size];
+ fLeafCount = size;
}
XERCES_CPP_NAMESPACE_END
diff --git a/src/xercesc/validators/common/ContentSpecNode.cpp b/src/xercesc/validators/common/ContentSpecNode.cpp
index 26f29196db4607397b4b007269ae66da1b8556a5..4b20af4b398b60cad5acfe30dd540805d8a552a4 100644
--- a/src/xercesc/validators/common/ContentSpecNode.cpp
+++ b/src/xercesc/validators/common/ContentSpecNode.cpp
@@ -81,23 +81,24 @@ XERCES_CPP_NAMESPACE_BEGIN
// aka inline function compilation error on AIX 4.2, xlC 3 r ev.1
// ---------------------------------------------------------------------------
-ContentSpecNode::ContentSpecNode(const ContentSpecNode& toCopy)
+ContentSpecNode::ContentSpecNode(const ContentSpecNode& toCopy) :
+ fMemoryManager(XMLPlatformUtils::fgMemoryManager)
{
const QName* tempElement = toCopy.getElement();
if (tempElement)
- fElement = new QName(*tempElement);
+ fElement = new (fMemoryManager) QName(*tempElement);
else
fElement = 0;
const ContentSpecNode *tmp = toCopy.getFirst();
if (tmp)
- fFirst = new ContentSpecNode(*tmp);
+ fFirst = new (fMemoryManager) ContentSpecNode(*tmp);
else
fFirst = 0;
tmp = toCopy.getSecond();
if (tmp)
- fSecond = new ContentSpecNode(*tmp);
+ fSecond = new (fMemoryManager) ContentSpecNode(*tmp);
else
fSecond = 0;
diff --git a/src/xercesc/validators/common/ContentSpecNode.hpp b/src/xercesc/validators/common/ContentSpecNode.hpp
index 8b5795636941e5d2e7ee96a377bc9ff73c708321..6ef7a1b9bc73cf597b61489fd76662129c4f8889 100644
--- a/src/xercesc/validators/common/ContentSpecNode.hpp
+++ b/src/xercesc/validators/common/ContentSpecNode.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -158,8 +161,8 @@
#if !defined(CONTENTSPECNODE_HPP)
#define CONTENTSPECNODE_HPP
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/framework/XMLElementDecl.hpp>
+#include <xercesc/framework/MemoryManager.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -167,7 +170,7 @@ class XMLBuffer;
class Grammar;
-class ContentSpecNode
+class ContentSpecNode : public XMemory
{
public :
// -----------------------------------------------------------------------
@@ -296,6 +299,7 @@ private :
// Indicate the maximum times that this node can occur
// -1 (Unbounded), default (1)
// -----------------------------------------------------------------------
+ MemoryManager* fMemoryManager;
QName* fElement;
ContentSpecNode* fFirst;
ContentSpecNode* fSecond;
@@ -311,7 +315,8 @@ private :
// ---------------------------------------------------------------------------
inline ContentSpecNode::ContentSpecNode() :
- fElement(0)
+ fMemoryManager(XMLPlatformUtils::fgMemoryManager)
+ , fElement(0)
, fFirst(0)
, fSecond(0)
, fType(ContentSpecNode::Leaf)
@@ -325,7 +330,8 @@ inline ContentSpecNode::ContentSpecNode() :
inline
ContentSpecNode::ContentSpecNode(QName* const element) :
- fElement(0)
+ fMemoryManager(XMLPlatformUtils::fgMemoryManager)
+ , fElement(0)
, fFirst(0)
, fSecond(0)
, fType(ContentSpecNode::Leaf)
@@ -335,14 +341,15 @@ ContentSpecNode::ContentSpecNode(QName* const element) :
, fMaxOccurs(1)
{
if (element)
- fElement = new QName(*element);
+ fElement = new (fMemoryManager) QName(*element);
}
inline
ContentSpecNode::ContentSpecNode(QName* const element
, const bool copyQName) :
- fElement(0)
+ fMemoryManager(XMLPlatformUtils::fgMemoryManager)
+ , fElement(0)
, fFirst(0)
, fSecond(0)
, fType(ContentSpecNode::Leaf)
@@ -354,7 +361,7 @@ ContentSpecNode::ContentSpecNode(QName* const element
if (copyQName)
{
if (element)
- fElement = new QName(*element);
+ fElement = new (fMemoryManager) QName(*element);
}
else
{
@@ -369,7 +376,8 @@ ContentSpecNode::ContentSpecNode(const NodeTypes type
, const bool adoptFirst
, const bool adoptSecond) :
- fElement(0)
+ fMemoryManager(XMLPlatformUtils::fgMemoryManager)
+ , fElement(0)
, fFirst(firstAdopt)
, fSecond(secondAdopt)
, fType(type)
@@ -476,7 +484,7 @@ inline void ContentSpecNode::setElement(QName* const element)
delete fElement;
fElement = 0;
if (element)
- fElement = new QName(*element);
+ fElement = new (fMemoryManager) QName(*element);
}
inline void ContentSpecNode::setFirst(ContentSpecNode* const toAdopt)
diff --git a/src/xercesc/validators/common/DFAContentModel.cpp b/src/xercesc/validators/common/DFAContentModel.cpp
index f7f5efec7c9152feb7acb608cc18b9fa4c990fd3..9fb0dd3fb96dbf2445d15152590cfbaf166f99e8 100644
--- a/src/xercesc/validators/common/DFAContentModel.cpp
+++ b/src/xercesc/validators/common/DFAContentModel.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -222,8 +225,9 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// DFAContentModel: Constructors and Destructor
// ---------------------------------------------------------------------------
-DFAContentModel::DFAContentModel(const bool dtd
- , ContentSpecNode* const elemContentSpec) :
+DFAContentModel::DFAContentModel( const bool dtd
+ , ContentSpecNode* const elemContentSpec
+ , MemoryManager* const manager) :
fElemMap(0)
, fElemMapType(0)
@@ -240,14 +244,16 @@ DFAContentModel::DFAContentModel(const bool dtd
, fDTD(dtd)
, fIsMixed(false)
, fLeafNameTypeVector(0)
+ , fMemoryManager(manager)
{
// And build the DFA data structures
buildDFA(elemContentSpec);
}
-DFAContentModel::DFAContentModel(const bool dtd
- , ContentSpecNode* const elemContentSpec
- , const bool isMixed ):
+DFAContentModel::DFAContentModel( const bool dtd
+ , ContentSpecNode* const elemContentSpec
+ , const bool isMixed
+ , MemoryManager* const manager):
fElemMap(0)
, fElemMapType(0)
@@ -264,6 +270,7 @@ DFAContentModel::DFAContentModel(const bool dtd
, fDTD(dtd)
, fIsMixed(isMixed)
, fLeafNameTypeVector(0)
+ , fMemoryManager(manager)
{
// And build the DFA data structures
buildDFA(elemContentSpec);
@@ -275,19 +282,19 @@ DFAContentModel::~DFAContentModel()
// Clean up all the stuff that is not just temporary representation
// data that was cleaned up after building the DFA.
//
- delete [] fFinalStateFlags;
+ fMemoryManager->deallocate(fFinalStateFlags); //delete [] fFinalStateFlags;
unsigned index;
for (index = 0; index < fTransTableSize; index++)
- delete [] fTransTable[index];
- delete [] fTransTable;
+ fMemoryManager->deallocate(fTransTable[index]); //delete [] fTransTable[index];
+ fMemoryManager->deallocate(fTransTable); //delete [] fTransTable;
for (index = 0; index < fLeafCount; index++)
delete fElemMap[index];
- delete [] fElemMap;
+ fMemoryManager->deallocate(fElemMap); //delete [] fElemMap;
- delete [] fElemMapType;
- delete [] fLeafListType;
+ fMemoryManager->deallocate(fElemMapType); //delete [] fElemMapType;
+ fMemoryManager->deallocate(fLeafListType); //delete [] fLeafListType;
delete fLeafNameTypeVector;
}
@@ -536,17 +543,25 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
// DFA state position and count the number of such leafs, which is left
// in the fLeafCount member.
//
- CMLeaf* nodeEOC = new CMLeaf(new QName(XMLUni::fgZeroLenString,
- XMLUni::fgZeroLenString,
- XMLContentModel::gEOCFakeId)
- , ~0
- , true);
+ CMLeaf* nodeEOC = new (fMemoryManager) CMLeaf
+ (
+ new (fMemoryManager) QName
+ (
+ XMLUni::fgZeroLenString
+ , XMLUni::fgZeroLenString
+ , XMLContentModel::gEOCFakeId
+ )
+ , ~0
+ , true
+ , fMemoryManager
+ );
CMNode* nodeOrgContent = buildSyntaxTree(curNode);
- fHeadNode = new CMBinaryOp
+ fHeadNode = new (fMemoryManager) CMBinaryOp
(
ContentSpecNode::Sequence
, nodeOrgContent
, nodeEOC
+ , fMemoryManager
);
//
@@ -573,8 +588,11 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
// initial tree build (which built their position numbers, we will put
// them in the array according to their position values.
//
- fLeafList = new CMLeaf*[fLeafCount];
- fLeafListType = new ContentSpecNode::NodeTypes[fLeafCount];
+ fLeafList = (CMLeaf**) fMemoryManager->allocate(fLeafCount*sizeof(CMLeaf*)); //new CMLeaf*[fLeafCount];
+ fLeafListType = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
+ (
+ fLeafCount * sizeof(ContentSpecNode::NodeTypes)
+ ); //new ContentSpecNode::NodeTypes[fLeafCount];
postTreeBuildInit(fHeadNode, 0);
//
@@ -582,9 +600,12 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
// for all the nodes. So we allocate an array of pointers to state sets,
// one for each leaf node (i.e. each significant DFA position.)
//
- fFollowList = new CMStateSet*[fLeafCount];
+ fFollowList = (CMStateSet**) fMemoryManager->allocate
+ (
+ fLeafCount * sizeof(CMStateSet*)
+ ); //new CMStateSet*[fLeafCount];
for (index = 0; index < fLeafCount; index++)
- fFollowList[index] = new CMStateSet(fLeafCount);
+ fFollowList[index] = new (fMemoryManager) CMStateSet(fLeafCount, fMemoryManager);
calcFollowList(fHeadNode);
//
@@ -608,18 +629,24 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
// So we need to a zero based range of indexes that map to element types.
// This element map provides that mapping.
//
- fElemMap = new QName*[fLeafCount];
- fElemMapType = new ContentSpecNode::NodeTypes[fLeafCount];
+ fElemMap = (QName**) fMemoryManager->allocate
+ (
+ fLeafCount * sizeof(QName*)
+ ); //new QName*[fLeafCount];
+ fElemMapType = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
+ (
+ fLeafCount * sizeof(ContentSpecNode::NodeTypes)
+ ); //new ContentSpecNode::NodeTypes[fLeafCount];
fElemMapSize = 0;
for (unsigned int outIndex = 0; outIndex < fLeafCount; outIndex++)
{
- fElemMap[outIndex] = new QName();
+ fElemMap[outIndex] = new (fMemoryManager) QName();
if ( (fLeafListType[outIndex] & 0x0f) != ContentSpecNode::Leaf )
if (!fLeafNameTypeVector)
- fLeafNameTypeVector = new ContentLeafNameTypeVector();
+ fLeafNameTypeVector = new (fMemoryManager) ContentLeafNameTypeVector(fMemoryManager);
// Get the current leaf's element index
const QName* element = fLeafList[outIndex]->getElement();
@@ -668,7 +695,10 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
**/
// don't forget to delete it
- int *fLeafSorter = new int[fLeafCount + fElemMapSize];
+ int *fLeafSorter = (int*) fMemoryManager->allocate
+ (
+ (fLeafCount + fElemMapSize) * sizeof(int)
+ ); //new int[fLeafCount + fElemMapSize];
unsigned int fSortCount = 0;
for (unsigned int elemIndex = 0; elemIndex < fElemMapSize; elemIndex++)
@@ -710,15 +740,25 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
// have to expand though, it if does, the overhead will be somewhat ugly.
//
unsigned int curArraySize = fLeafCount * 4;
- const CMStateSet** statesToDo = new const CMStateSet*[curArraySize];
- fFinalStateFlags = new bool[curArraySize];
- fTransTable = new unsigned int*[curArraySize];
+ const CMStateSet** statesToDo = (const CMStateSet**)
+ fMemoryManager->allocate
+ (
+ curArraySize * sizeof(const CMStateSet*)
+ ); //new const CMStateSet*[curArraySize];
+ fFinalStateFlags = (bool*) fMemoryManager->allocate
+ (
+ curArraySize * sizeof(bool)
+ ); //new bool[curArraySize];
+ fTransTable = (unsigned int**) fMemoryManager->allocate
+ (
+ curArraySize * sizeof(unsigned int*)
+ ); //new unsigned int*[curArraySize];
//
// Ok we start with the initial set as the first pos set of the head node
// (which is the seq node that holds the content model and the EOC node.)
//
- const CMStateSet* setT = new CMStateSet(fHeadNode->getFirstPos());
+ const CMStateSet* setT = new (fMemoryManager) CMStateSet(fHeadNode->getFirstPos());
//
// Init our two state flags. Basically the unmarked state counter is
@@ -747,8 +787,14 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
//
// TODO: in the future, we may change the 29 to something
// derived from curArraySize.
- RefHashTableOf<XMLInteger> *stateTable = new RefHashTableOf<XMLInteger>(curArraySize, true, new HashCMStateSet());
- //stateTable->put((CMStateSet*)setT, new XMLInteger(0));
+ RefHashTableOf<XMLInteger> *stateTable =
+ new (fMemoryManager) RefHashTableOf<XMLInteger>
+ (
+ curArraySize
+ , true
+ , new (fMemoryManager) HashCMStateSet()
+ );
+ //stateTable->put((CMStateSet*)setT, new (fMemoryManager) XMLInteger(0));
//
// Ok, almost done with the algorithm from hell... We now enter the
@@ -785,7 +831,11 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
// one. Otherwise, zero out the existing one.
//
if (!newSet)
- newSet = new CMStateSet(fLeafCount);
+ newSet = new (fMemoryManager) CMStateSet
+ (
+ fLeafCount
+ , fMemoryManager
+ );
else
newSet->zeroBits();
@@ -868,7 +918,11 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
//
statesToDo[curState] = newSet;
fTransTable[curState] = makeDefStateList();
- stateTable->put(newSet, new XMLInteger(curState));
+ stateTable->put
+ (
+ newSet
+ , new (fMemoryManager) XMLInteger(curState)
+ );
// We now have a new state to do so bump the count
curState++;
@@ -897,9 +951,20 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
// size by 50% and allocate new arrays.
//
const unsigned int newSize = (unsigned int)(curArraySize * 1.5);
- const CMStateSet** newToDo = new const CMStateSet*[newSize];
- bool* newFinalFlags = new bool[newSize];
- unsigned int** newTransTable = new unsigned int*[newSize];
+ const CMStateSet** newToDo = (const CMStateSet**)
+ fMemoryManager->allocate
+ (
+ newSize * sizeof(const CMStateSet*)
+ ); //new const CMStateSet*[newSize];
+ bool* newFinalFlags = (bool*) fMemoryManager->allocate
+ (
+ newSize * sizeof(bool)
+ ); //new bool[newSize];
+ unsigned int** newTransTable = (unsigned int**)
+ fMemoryManager->allocate
+ (
+ newSize * sizeof(unsigned int*)
+ ); //new unsigned int*[newSize];
// Copy over all of the existing content
for (unsigned int expIndex = 0; expIndex < curArraySize; expIndex++)
@@ -910,9 +975,9 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
}
// Clean up the old stuff
- delete [] statesToDo;
- delete [] fFinalStateFlags;
- delete [] fTransTable;
+ fMemoryManager->deallocate(statesToDo); //delete [] statesToDo;
+ fMemoryManager->deallocate(fFinalStateFlags); //delete [] fFinalStateFlags;
+ fMemoryManager->deallocate(fTransTable); //delete [] fTransTable;
// Store the new array size and pointers
curArraySize = newSize;
@@ -951,7 +1016,7 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
for (index = 0; index < fLeafCount; index++)
delete fFollowList[index];
- delete [] fFollowList;
+ fMemoryManager->deallocate(fFollowList); //delete [] fFollowList;
//
// removeAll() will delete all data, XMLInteger,
@@ -962,13 +1027,13 @@ void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
for (index = 0; index < curState; index++)
delete (CMStateSet*)statesToDo[index];
- delete [] statesToDo;
+ fMemoryManager->deallocate(statesToDo); //delete [] statesToDo;
for (index = 0; index < fLeafCount; index++)
delete fLeafList[index];
- delete [] fLeafList;
+ fMemoryManager->deallocate(fLeafList); //delete [] fLeafList;
- delete [] fLeafSorter;
+ fMemoryManager->deallocate(fLeafSorter); //delete [] fLeafSorter;
}
@@ -985,7 +1050,13 @@ CMNode* DFAContentModel::buildSyntaxTree(ContentSpecNode* const curNode)
|| (curType & 0x0f) == ContentSpecNode::Any_Other
|| (curType & 0x0f) == ContentSpecNode::Any_NS)
{
- retNode = new CMAny(curType, curNode->getElement()->getURI(), fLeafCount++);
+ retNode = new (fMemoryManager) CMAny
+ (
+ curType
+ , curNode->getElement()->getURI()
+ , fLeafCount++
+ , fMemoryManager
+ );
}
else if (curType == ContentSpecNode::Leaf)
{
@@ -995,7 +1066,12 @@ CMNode* DFAContentModel::buildSyntaxTree(ContentSpecNode* const curNode)
// This makes the positions zero based since we store first and then
// increment.
//
- retNode = new CMLeaf(curNode->getElement(), fLeafCount++);
+ retNode = new (fMemoryManager) CMLeaf
+ (
+ curNode->getElement()
+ , fLeafCount++
+ , fMemoryManager
+ );
}
else
{
@@ -1016,14 +1092,25 @@ CMNode* DFAContentModel::buildSyntaxTree(ContentSpecNode* const curNode)
//
CMNode* newLeft = buildSyntaxTree(leftNode);
CMNode* newRight = buildSyntaxTree(rightNode);
- retNode = new CMBinaryOp(curType, newLeft, newRight);
+ retNode = new (fMemoryManager) CMBinaryOp
+ (
+ curType
+ , newLeft
+ , newRight
+ , fMemoryManager
+ );
}
else if (curType == ContentSpecNode::ZeroOrMore
|| curType == ContentSpecNode::ZeroOrOne
|| curType == ContentSpecNode::OneOrMore)
{
// This one is fine as is, just change to our form
- retNode = new CMUnaryOp(curType, buildSyntaxTree(leftNode));
+ retNode = new (fMemoryManager) CMUnaryOp
+ (
+ curType
+ , buildSyntaxTree(leftNode)
+ , fMemoryManager
+ );
}
else
{
@@ -1108,7 +1195,10 @@ void DFAContentModel::calcFollowList(CMNode* const curNode)
//
unsigned int* DFAContentModel::makeDefStateList() const
{
- unsigned int* retArray = new unsigned int[fElemMapSize];
+ unsigned int* retArray = (unsigned int*) fMemoryManager->allocate
+ (
+ fElemMapSize * sizeof(unsigned int)
+ ); //new unsigned int[fElemMapSize];
for (unsigned int index = 0; index < fElemMapSize; index++)
retArray[index] = XMLContentModel::gInvalidTrans;
return retArray;
@@ -1132,11 +1222,18 @@ int DFAContentModel::postTreeBuildInit( CMNode* const nodeCur
((curType & 0x0f) == ContentSpecNode::Any_NS) ||
((curType & 0x0f) == ContentSpecNode::Any_Other) )
{
- fLeafList[newIndex] = new CMLeaf(new QName(XMLUni::fgZeroLenString
- , XMLUni::fgZeroLenString
- , ((CMAny*) nodeCur)->getURI())
- , ((CMAny*)nodeCur)->getPosition()
- , true);
+ fLeafList[newIndex] = new (fMemoryManager) CMLeaf
+ (
+ new (fMemoryManager) QName
+ (
+ XMLUni::fgZeroLenString
+ , XMLUni::fgZeroLenString
+ , ((CMAny*) nodeCur)->getURI()
+ )
+ , ((CMAny*)nodeCur)->getPosition()
+ , true
+ , fMemoryManager
+ );
fLeafListType[newIndex] = curType;
++newIndex;
}
@@ -1166,8 +1263,12 @@ int DFAContentModel::postTreeBuildInit( CMNode* const nodeCur
// will NOT delete the nodeCur --twice--,
// thuse to make delete the owner of the nodeCur possible.
//
- fLeafList[newIndex] = new CMLeaf(((CMLeaf*)nodeCur)->getElement(),
- ((CMLeaf*)nodeCur)->getPosition());
+ fLeafList[newIndex] = new (fMemoryManager) CMLeaf
+ (
+ ((CMLeaf*)nodeCur)->getElement()
+ , ((CMLeaf*)nodeCur)->getPosition()
+ , fMemoryManager
+ );
fLeafListType[newIndex] = ContentSpecNode::Leaf;
++newIndex;
}
@@ -1214,11 +1315,17 @@ void DFAContentModel::checkUniqueParticleAttribution (SchemaGrammar* const pG
// Unique Particle Attribution
// store the conflict results between any two elements in fElemMap
// XMLContentModel::gInvalidTrans: not compared; 0: no conflict; 1: conflict
- unsigned int** fConflictTable = new unsigned int*[fElemMapSize];
+ unsigned int** fConflictTable = (unsigned int**) fMemoryManager->allocate
+ (
+ fElemMapSize * sizeof(unsigned int*)
+ ); //new unsigned int*[fElemMapSize];
// initialize the conflict table
for (j = 0; j < fElemMapSize; j++) {
- fConflictTable[j] = new unsigned int[fElemMapSize];
+ fConflictTable[j] = (unsigned int*) fMemoryManager->allocate
+ (
+ fElemMapSize * sizeof(unsigned int)
+ ); //new unsigned int[fElemMapSize];
for (k = j+1; k < fElemMapSize; k++)
fConflictTable[j][k] = XMLContentModel::gInvalidTrans;
}
@@ -1275,8 +1382,8 @@ void DFAContentModel::checkUniqueParticleAttribution (SchemaGrammar* const pG
}
for (i = 0; i < fElemMapSize; i++)
- delete [] fConflictTable[i];
- delete [] fConflictTable;
+ fMemoryManager->deallocate(fConflictTable[i]); //delete [] fConflictTable[i];
+ fMemoryManager->deallocate(fConflictTable); //delete [] fConflictTable;
}
XERCES_CPP_NAMESPACE_END
diff --git a/src/xercesc/validators/common/DFAContentModel.hpp b/src/xercesc/validators/common/DFAContentModel.hpp
index 54c7815b492ff9be266a37b7b28f9a2b15666010..48c645888ddf028a822a226e25f509f3d2ee0299 100644
--- a/src/xercesc/validators/common/DFAContentModel.hpp
+++ b/src/xercesc/validators/common/DFAContentModel.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2003/03/07 18:16:57 tng
* Return a reference instead of void for operator=
*
@@ -157,12 +160,19 @@ public:
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- DFAContentModel(const bool dtd
- , ContentSpecNode* const elemContentSpec);
-
- DFAContentModel(const bool dtd
- , ContentSpecNode* const elemContentSpec
- , const bool isMixed);
+ DFAContentModel
+ (
+ const bool dtd
+ , ContentSpecNode* const elemContentSpec
+ , MemoryManager* const manager
+ );
+ DFAContentModel
+ (
+ const bool dtd
+ , ContentSpecNode* const elemContentSpec
+ , const bool isMixed
+ , MemoryManager* const manager
+ );
virtual ~DFAContentModel();
@@ -316,6 +326,7 @@ private :
bool fDTD;
bool fIsMixed;
ContentLeafNameTypeVector *fLeafNameTypeVector;
+ MemoryManager* fMemoryManager;
};
diff --git a/src/xercesc/validators/common/Grammar.hpp b/src/xercesc/validators/common/Grammar.hpp
index e401208e13bb935fa2ced89785fc8668a38ee2bd..3ce470bbbb0f9cb47838b85f4fc295c9014f6ed1 100644
--- a/src/xercesc/validators/common/Grammar.hpp
+++ b/src/xercesc/validators/common/Grammar.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -103,7 +106,7 @@ XERCES_CPP_NAMESPACE_BEGIN
// This abstract class specifies the interface for a Grammar
//
-class VALIDATORS_EXPORT Grammar
+class VALIDATORS_EXPORT Grammar : public XMemory
{
public:
diff --git a/src/xercesc/validators/common/GrammarResolver.cpp b/src/xercesc/validators/common/GrammarResolver.cpp
index bd45486cd48c3d2644b1dbb7ed44ab197fbc895c..58529e2d0ab24a8a2cafaa2f87a79da2180ad8bd 100644
--- a/src/xercesc/validators/common/GrammarResolver.cpp
+++ b/src/xercesc/validators/common/GrammarResolver.cpp
@@ -57,6 +57,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -99,14 +102,15 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// GrammarResolver: Constructor and Destructor
// ---------------------------------------------------------------------------
-GrammarResolver::GrammarResolver() :
+GrammarResolver::GrammarResolver(MemoryManager* const manager) :
fCacheGrammar(false)
, fUseCachedGrammar(false)
, fGrammarRegistry(0)
, fCachedGrammarRegistry(0)
, fDataTypeReg(0)
+ , fMemoryManager(manager)
{
- fGrammarRegistry = new RefHashTableOf<Grammar>(29, true);
+ fGrammarRegistry = new (manager) RefHashTableOf<Grammar>(29, true);
}
GrammarResolver::~GrammarResolver()
@@ -130,7 +134,7 @@ GrammarResolver::getDatatypeValidator(const XMLCh* const uriStr,
if (!fDataTypeReg) {
- fDataTypeReg = new DatatypeValidatorFactory();
+ fDataTypeReg = new (fMemoryManager) DatatypeValidatorFactory(fMemoryManager);
fDataTypeReg->expandRegistryToFullSchemaSet();
}
@@ -222,7 +226,7 @@ void GrammarResolver::cacheGrammars()
}
if (!fCachedGrammarRegistry)
- fCachedGrammarRegistry = new RefHashTableOf<Grammar>(29, true);
+ fCachedGrammarRegistry = new (fMemoryManager) RefHashTableOf<Grammar>(29, true);
// Cache
for (unsigned int i=0; i<keyCount; i++) {
@@ -240,7 +244,7 @@ void GrammarResolver::cacheGrammars()
void GrammarResolver::cacheGrammarFromParse(const bool aValue) {
if (aValue && !fCachedGrammarRegistry) {
- fCachedGrammarRegistry = new RefHashTableOf<Grammar>(29, true);
+ fCachedGrammarRegistry = new (fMemoryManager) RefHashTableOf<Grammar>(29, true);
}
fCacheGrammar = aValue;
diff --git a/src/xercesc/validators/common/GrammarResolver.hpp b/src/xercesc/validators/common/GrammarResolver.hpp
index 1734f200f84e4e83f993cfd40ee8c8d4d0bd4b24..11e86ac664d5a691dfd68a1908269d86658bf14d 100644
--- a/src/xercesc/validators/common/GrammarResolver.hpp
+++ b/src/xercesc/validators/common/GrammarResolver.hpp
@@ -79,7 +79,8 @@ class DatatypeValidatorFactory;
*
*/
-class VALIDATORS_EXPORT GrammarResolver {
+class VALIDATORS_EXPORT GrammarResolver : public XMemory
+{
public:
/** @name Constructor and Destructor */
@@ -88,7 +89,7 @@ public:
*
* Default Constructor
*/
- GrammarResolver();
+ GrammarResolver(MemoryManager* const manager);
/**
* Destructor
@@ -208,6 +209,8 @@ private:
//
// fDataTypeReg DatatypeValidatorFactory registery
//
+ // fMemoryManager Pluggable memory manager for dynamic memory
+ // allocation/deallocation
// -----------------------------------------------------------------------
bool fCacheGrammar;
bool fUseCachedGrammar;
@@ -215,6 +218,7 @@ private:
RefHashTableOf<Grammar>* fGrammarRegistry;
RefHashTableOf<Grammar>* fCachedGrammarRegistry;
DatatypeValidatorFactory* fDataTypeReg;
+ MemoryManager* fMemoryManager;
};
inline XMLStringPool* GrammarResolver::getStringPool() {
diff --git a/src/xercesc/validators/common/MixedContentModel.cpp b/src/xercesc/validators/common/MixedContentModel.cpp
index 9886387f9f90d6280e0fb22059362b9b7ac0324c..e918b819cce824f2f20babd9403cdafe0a261099 100644
--- a/src/xercesc/validators/common/MixedContentModel.cpp
+++ b/src/xercesc/validators/common/MixedContentModel.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/11/04 14:54:58 tng
* C++ Namespace Support.
*
@@ -154,6 +157,7 @@ MixedContentModel::MixedContentModel(const bool dtd
, fChildTypes(0)
, fOrdered(ordered)
, fDTD(dtd)
+ , fMemoryManager(XMLPlatformUtils::fgMemoryManager)
{
//
// Create a vector of unsigned ints that will be filled in with the
@@ -161,7 +165,6 @@ MixedContentModel::MixedContentModel(const bool dtd
// it an initial capacity of 64 which should be more than enough for
// 99% of the scenarios.
//
-
ValueVectorOf<QName*> children(64);
ValueVectorOf<ContentSpecNode::NodeTypes> childTypes(64);
@@ -182,8 +185,11 @@ MixedContentModel::MixedContentModel(const bool dtd
// fill them in.
//
fCount = children.size();
- fChildren = new QName*[fCount];
- fChildTypes = new ContentSpecNode::NodeTypes[fCount];
+ fChildren = (QName**) fMemoryManager->allocate(fCount * sizeof(QName*)); //new QName*[fCount];
+ fChildTypes = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
+ (
+ fCount * sizeof(ContentSpecNode::NodeTypes)
+ ); //new ContentSpecNode::NodeTypes[fCount];
for (unsigned int index = 0; index < fCount; index++) {
fChildren[index] = children.elementAt(index);
fChildTypes[index] = childTypes.elementAt(index);
@@ -192,8 +198,8 @@ MixedContentModel::MixedContentModel(const bool dtd
MixedContentModel::~MixedContentModel()
{
- delete [] fChildren;
- delete [] fChildTypes;
+ fMemoryManager->deallocate(fChildren); //delete [] fChildren;
+ fMemoryManager->deallocate(fChildTypes); //delete [] fChildTypes;
}
diff --git a/src/xercesc/validators/common/MixedContentModel.hpp b/src/xercesc/validators/common/MixedContentModel.hpp
index 7e255bd7bc0e3de33380973ec55a6d3cc054c830..73bc0b630a9fcf8203ffbfb44ff71c4ff60e7f56 100644
--- a/src/xercesc/validators/common/MixedContentModel.hpp
+++ b/src/xercesc/validators/common/MixedContentModel.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2003/03/07 18:16:57 tng
* Return a reference instead of void for operator=
*
@@ -238,12 +241,12 @@ private :
// Boolean to allow DTDs to validate even with namespace support.
//
// -----------------------------------------------------------------------
- unsigned int fCount;
- QName** fChildren;
- ContentSpecNode::NodeTypes* fChildTypes;
- bool fOrdered;
- bool fDTD;
-
+ unsigned int fCount;
+ QName** fChildren;
+ ContentSpecNode::NodeTypes* fChildTypes;
+ bool fOrdered;
+ bool fDTD;
+ MemoryManager* fMemoryManager;
};
inline ContentLeafNameTypeVector* MixedContentModel::getContentLeafNameTypeVector() const
diff --git a/src/xercesc/validators/common/SimpleContentModel.hpp b/src/xercesc/validators/common/SimpleContentModel.hpp
index a4b0823f993ac50787ab501c059c1b98fd015d38..3684dd167bee752e087ef6d0283ec5a3a706bba8 100644
--- a/src/xercesc/validators/common/SimpleContentModel.hpp
+++ b/src/xercesc/validators/common/SimpleContentModel.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:48:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2003/03/07 18:16:57 tng
* Return a reference instead of void for operator=
*
@@ -240,26 +243,27 @@ public :
// ---------------------------------------------------------------------------
// SimpleContentModel: Constructors and Destructor
// ---------------------------------------------------------------------------
-inline
-SimpleContentModel::SimpleContentModel( const bool dtd
- , QName* const firstChild
- , QName* const secondChild
- , const ContentSpecNode::NodeTypes cmOp) :
-
- fFirstChild(0)
+inline SimpleContentModel::SimpleContentModel
+(
+ const bool dtd
+ , QName* const firstChild
+ , QName* const secondChild
+ , const ContentSpecNode::NodeTypes cmOp
+)
+ : fFirstChild(0)
, fSecondChild(0)
, fOp(cmOp)
, fDTD(dtd)
{
if (firstChild)
- fFirstChild = new QName(*firstChild);
+ fFirstChild = new (XMLPlatformUtils::fgMemoryManager) QName(*firstChild);
else
- fFirstChild = new QName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, XMLElementDecl::fgInvalidElemId);
+ fFirstChild = new (XMLPlatformUtils::fgMemoryManager) QName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, XMLElementDecl::fgInvalidElemId);
if (secondChild)
- fSecondChild = new QName(*secondChild);
+ fSecondChild = new (XMLPlatformUtils::fgMemoryManager) QName(*secondChild);
else
- fSecondChild = new QName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, XMLElementDecl::fgInvalidElemId);
+ fSecondChild = new (XMLPlatformUtils::fgMemoryManager) QName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, XMLElementDecl::fgInvalidElemId);
}
inline SimpleContentModel::~SimpleContentModel()
diff --git a/src/xercesc/validators/datatype/AbstractNumericFacetValidator.cpp b/src/xercesc/validators/datatype/AbstractNumericFacetValidator.cpp
index 86c973c5d894c3a33203230c85f287297dfc85f6..716c59e2aab24c04bb3035880b96df696aff1c53 100644
--- a/src/xercesc/validators/datatype/AbstractNumericFacetValidator.cpp
+++ b/src/xercesc/validators/datatype/AbstractNumericFacetValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.12 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.11 2003/02/03 16:34:35 peiyongz
* fix to misplaced derived and base value in error message.
*
@@ -115,7 +118,6 @@
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/validators/datatype/AbstractNumericFacetValidator.hpp>
-#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
#include <xercesc/util/NumberFormatException.hpp>
@@ -174,8 +176,9 @@ AbstractNumericFacetValidator::AbstractNumericFacetValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:DatatypeValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:DatatypeValidator(baseValidator, facets, finalSet, type, manager)
, fMaxInclusiveInherited(false)
, fMaxExclusiveInherited(false)
, fMinInclusiveInherited(false)
@@ -655,6 +658,7 @@ void AbstractNumericFacetValidator::inspectFacetBase()
{
REPORT_FACET_ERROR(thisMinExclusive
, baseMaxInclusive
+
, XMLExcepts::FACET_minExcl_base_maxIncl)
}
}
diff --git a/src/xercesc/validators/datatype/AbstractNumericFacetValidator.hpp b/src/xercesc/validators/datatype/AbstractNumericFacetValidator.hpp
index 0b89411a12b2d4efa5c132e76c99465abadcd58e..d7e55834fb419de5e8713c02913bb22898bcd08e 100644
--- a/src/xercesc/validators/datatype/AbstractNumericFacetValidator.hpp
+++ b/src/xercesc/validators/datatype/AbstractNumericFacetValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.6 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -111,10 +114,14 @@ public:
protected:
- AbstractNumericFacetValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ AbstractNumericFacetValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
void init(RefArrayVectorOf<XMLCh>* const enums);
diff --git a/src/xercesc/validators/datatype/AbstractNumericValidator.cpp b/src/xercesc/validators/datatype/AbstractNumericValidator.cpp
index dde872f3e77316b0d76f0c6830e1376790c4a374..a18e904bc72ba621eeb2c7c034bde99b047ab2fe 100644
--- a/src/xercesc/validators/datatype/AbstractNumericValidator.cpp
+++ b/src/xercesc/validators/datatype/AbstractNumericValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.5 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2003/02/02 23:55:40 peiyongz
* getFormattedString() added to return original and converted value.
*
@@ -101,8 +104,9 @@ AbstractNumericValidator::AbstractNumericValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:AbstractNumericFacetValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:AbstractNumericFacetValidator(baseValidator, facets, finalSet, type, manager)
{
//do not invoke init() here !!!
}
diff --git a/src/xercesc/validators/datatype/AbstractNumericValidator.hpp b/src/xercesc/validators/datatype/AbstractNumericValidator.hpp
index b62c53866e77ee4aab771e11265aaee1249d9052..371ebd140342de93112cd66db472cd67c75547d2 100644
--- a/src/xercesc/validators/datatype/AbstractNumericValidator.hpp
+++ b/src/xercesc/validators/datatype/AbstractNumericValidator.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -79,7 +82,6 @@
#include <xercesc/validators/datatype/AbstractNumericFacetValidator.hpp>
#include <xercesc/util/RefVectorOf.hpp>
-#include <xercesc/util/XMLNumber.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -101,10 +103,14 @@ public:
protected:
- AbstractNumericValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ AbstractNumericValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
inline void init(RefArrayVectorOf<XMLCh>* const enums);
diff --git a/src/xercesc/validators/datatype/AbstractStringValidator.cpp b/src/xercesc/validators/datatype/AbstractStringValidator.cpp
index d8f4750b394a1d4f4f059ae302a191a09b860c6a..35b75f251a37f41c3cf87d567e0906460919469e 100644
--- a/src/xercesc/validators/datatype/AbstractStringValidator.cpp
+++ b/src/xercesc/validators/datatype/AbstractStringValidator.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.11 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.10 2003/02/22 18:28:26 peiyongz
* Schema Errata E2-35 Length, minLength and maxLength in different derivation steps.
*
@@ -122,7 +125,6 @@
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/validators/datatype/AbstractStringValidator.hpp>
-#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
#include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
#include <xercesc/util/NumberFormatException.hpp>
@@ -167,8 +169,9 @@ AbstractStringValidator::AbstractStringValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:DatatypeValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:DatatypeValidator(baseValidator, facets, finalSet, type, manager)
,fLength(0)
,fMaxLength(SchemaSymbols::fgINT_MAX_VALUE)
,fMinLength(0)
@@ -643,7 +646,7 @@ void AbstractStringValidator::checkContent( const XMLCh* const content, bool asB
// lazy construction
if (getRegex() ==0) {
try {
- setRegex(new RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
+ setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
}
catch (XMLException &e)
{
@@ -698,8 +701,8 @@ void AbstractStringValidator::checkContent( const XMLCh* const content, bool asB
if ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0 &&
(getEnumeration() != 0))
{
- XMLCh* normContent = XMLString::replicate(content);
- ArrayJanitor<XMLCh> jan(normContent);
+ XMLCh* normContent = XMLString::replicate(content, fMemoryManager);
+ ArrayJanitor<XMLCh> jan(normContent, fMemoryManager);
normalizeContent(normContent);
int i=0;
diff --git a/src/xercesc/validators/datatype/AbstractStringValidator.hpp b/src/xercesc/validators/datatype/AbstractStringValidator.hpp
index 5540c838548e06cd473114c263d0b7190d7468a6..3d34fe4f8ec791c7aac432010f0ab3c4488c70e7 100644
--- a/src/xercesc/validators/datatype/AbstractStringValidator.hpp
+++ b/src/xercesc/validators/datatype/AbstractStringValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.8 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.7 2003/01/27 19:24:17 peiyongz
* normalize Base64 data before checking against enumeration.
*
@@ -170,10 +173,14 @@ public:
protected:
- AbstractStringValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ AbstractStringValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
void init(RefArrayVectorOf<XMLCh>* const enums);
diff --git a/src/xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.cpp b/src/xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.cpp
index fbed7be0554eef216ec61ad6bf8e8284e9f40b2c..7d0e99a0d3fb2d42a78d35cf2a250b7f19ae27e5 100644
--- a/src/xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2003/01/13 20:16:51 knoaman
* [Bug 16024] SchemaSymbols.hpp conflicts C++ Builder 6 dir.h
*
@@ -82,7 +85,6 @@
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.hpp>
-#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/util/RuntimeException.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -90,8 +92,8 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// AnySimpleTypeDatatypeValidator: Constructors and Destructor
// ---------------------------------------------------------------------------
-AnySimpleTypeDatatypeValidator::AnySimpleTypeDatatypeValidator()
- : DatatypeValidator(0, 0, SchemaSymbols::XSD_RESTRICTION, DatatypeValidator::AnySimpleType)
+AnySimpleTypeDatatypeValidator::AnySimpleTypeDatatypeValidator(MemoryManager* const manager)
+ : DatatypeValidator(0, 0, SchemaSymbols::XSD_RESTRICTION, DatatypeValidator::AnySimpleType, manager)
{
}
@@ -104,11 +106,14 @@ AnySimpleTypeDatatypeValidator::~AnySimpleTypeDatatypeValidator()
// ---------------------------------------------------------------------------
// AnySimpleTypeDatatypeValidator: Instance methods
// ---------------------------------------------------------------------------
-DatatypeValidator*
-AnySimpleTypeDatatypeValidator::newInstance(RefHashTableOf<KVStringPair>* const facets,
- RefArrayVectorOf<XMLCh>* const enums,
- const int finalSet) {
-
+DatatypeValidator* AnySimpleTypeDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
+{
// We own them, so we will delete them first
delete facets;
delete enums;
diff --git a/src/xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.hpp b/src/xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.hpp
index 02e6c1ba6a3b924ff1ece1d96d86d294c2dfb29c..022b6d017080caf9cab29679198cee0cd217a171 100644
--- a/src/xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/AnySimpleTypeDatatypeValidator.hpp
@@ -74,7 +74,10 @@ public:
/** @name Constructor */
//@{
- AnySimpleTypeDatatypeValidator();
+ AnySimpleTypeDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
//@}
@@ -158,9 +161,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const,
- RefArrayVectorOf<XMLCh>* const enums,
- const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
};
diff --git a/src/xercesc/validators/datatype/AnyURIDatatypeValidator.cpp b/src/xercesc/validators/datatype/AnyURIDatatypeValidator.cpp
index adf7d5675946107dd9cb229cea552d15ede079e1..8ec1e12194618863faf03c573ee81e951573c91c 100644
--- a/src/xercesc/validators/datatype/AnyURIDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/AnyURIDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -126,8 +129,8 @@ static const XMLCh BASE_URI[] =
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-AnyURIDatatypeValidator::AnyURIDatatypeValidator()
-:AbstractStringValidator(0, 0, 0, DatatypeValidator::AnyURI)
+AnyURIDatatypeValidator::AnyURIDatatypeValidator(MemoryManager* const manager)
+:AbstractStringValidator(0, 0, 0, DatatypeValidator::AnyURI, manager)
,fTempURI(0)
{}
@@ -140,8 +143,9 @@ AnyURIDatatypeValidator::AnyURIDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::AnyURI)
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::AnyURI, manager)
,fTempURI(0)
{
try
@@ -158,9 +162,10 @@ AnyURIDatatypeValidator::AnyURIDatatypeValidator(
DatatypeValidator* AnyURIDatatypeValidator::newInstance(
RefHashTableOf<KVStringPair>* const facets
, RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+ , const int finalSet
+ , MemoryManager* const manager)
{
- return (DatatypeValidator*) new AnyURIDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new AnyURIDatatypeValidator(this, facets, enums, finalSet, manager);
}
// ---------------------------------------------------------------------------
diff --git a/src/xercesc/validators/datatype/AnyURIDatatypeValidator.hpp b/src/xercesc/validators/datatype/AnyURIDatatypeValidator.hpp
index 9e7edb787882102bb60f3151d46a7edce18eb8b7..5ca7fda85e32c3fb3b18f2be98fc5a3bcf6fcea9 100644
--- a/src/xercesc/validators/datatype/AnyURIDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/AnyURIDatatypeValidator.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -111,16 +114,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- AnyURIDatatypeValidator();
-
- AnyURIDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ AnyURIDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ AnyURIDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~AnyURIDatatypeValidator();
//@}
@@ -129,9 +137,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/Base64BinaryDatatypeValidator.cpp b/src/xercesc/validators/datatype/Base64BinaryDatatypeValidator.cpp
index baf5d4fb0a796654c33001c7c12c3956b20ce26b..cf123a778c7741db8795a8aa3e201c12fe157e75 100644
--- a/src/xercesc/validators/datatype/Base64BinaryDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/Base64BinaryDatatypeValidator.cpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2003/01/27 19:24:17 peiyongz
* normalize Base64 data before checking against enumeration.
*
@@ -123,8 +126,8 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-Base64BinaryDatatypeValidator::Base64BinaryDatatypeValidator()
-:AbstractStringValidator(0, 0, 0, DatatypeValidator::Base64Binary)
+Base64BinaryDatatypeValidator::Base64BinaryDatatypeValidator(MemoryManager* const manager)
+:AbstractStringValidator(0, 0, 0, DatatypeValidator::Base64Binary, manager)
{}
Base64BinaryDatatypeValidator::~Base64BinaryDatatypeValidator()
@@ -133,19 +136,23 @@ Base64BinaryDatatypeValidator::~Base64BinaryDatatypeValidator()
Base64BinaryDatatypeValidator::Base64BinaryDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::Base64Binary)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::Base64Binary, manager)
{
init(enums);
}
-DatatypeValidator* Base64BinaryDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* Base64BinaryDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new Base64BinaryDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) Base64BinaryDatatypeValidator(this, facets, enums, finalSet, manager);
}
// ---------------------------------------------------------------------------
diff --git a/src/xercesc/validators/datatype/Base64BinaryDatatypeValidator.hpp b/src/xercesc/validators/datatype/Base64BinaryDatatypeValidator.hpp
index f4b721e4711bd413ff2e7a0919c9b548388c9316..a2f4e3fe21de070dc57ef04ccb418e9d667e4faf 100644
--- a/src/xercesc/validators/datatype/Base64BinaryDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/Base64BinaryDatatypeValidator.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 1999-2001 The Apache Software Foundation. All rights
+ * Copyright (c) 1999-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.6 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2003/01/27 19:24:17 peiyongz
* normalize Base64 data before checking against enumeration.
*
@@ -94,16 +97,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- Base64BinaryDatatypeValidator();
-
- Base64BinaryDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ Base64BinaryDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ Base64BinaryDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~Base64BinaryDatatypeValidator();
//@}
@@ -112,9 +120,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/BooleanDatatypeValidator.cpp b/src/xercesc/validators/datatype/BooleanDatatypeValidator.cpp
index a5da5d2013398a47768a80bafbf1bb5c020974ee..e207c18997cfc7d8b45a7203faa0105e0d14e88f 100644
--- a/src/xercesc/validators/datatype/BooleanDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/BooleanDatatypeValidator.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.6 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -122,9 +125,10 @@ const XMLCh fgValueSpace[][32] =
BooleanDatatypeValidator::BooleanDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::Boolean)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::Boolean, manager)
{
// Set Facets if any defined
@@ -180,7 +184,7 @@ void BooleanDatatypeValidator::checkContent( const XMLCh* const content, bool as
// lazy construction
if (getRegex() ==0) {
try {
- setRegex(new RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
+ setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
}
catch (XMLException &e)
{
diff --git a/src/xercesc/validators/datatype/BooleanDatatypeValidator.hpp b/src/xercesc/validators/datatype/BooleanDatatypeValidator.hpp
index a2c5fd308033691160c219f9551167ae3262348b..16403204d231e715b781e1213caae1df0edff5c2 100644
--- a/src/xercesc/validators/datatype/BooleanDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/BooleanDatatypeValidator.hpp
@@ -75,12 +75,18 @@ public:
/** @name Constructor. */
//@{
- BooleanDatatypeValidator();
-
- BooleanDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ BooleanDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ BooleanDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~BooleanDatatypeValidator();
@@ -136,9 +142,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
private:
@@ -154,8 +164,8 @@ private:
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-inline BooleanDatatypeValidator::BooleanDatatypeValidator()
-:DatatypeValidator(0, 0, 0, DatatypeValidator::Boolean)
+inline BooleanDatatypeValidator::BooleanDatatypeValidator(MemoryManager* const manager)
+:DatatypeValidator(0, 0, 0, DatatypeValidator::Boolean, manager)
{
}
@@ -172,12 +182,15 @@ inline BooleanDatatypeValidator::~BooleanDatatypeValidator()
// Compare methods
// -----------------------------------------------------------------------
-inline DatatypeValidator* BooleanDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+inline DatatypeValidator* BooleanDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new BooleanDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) BooleanDatatypeValidator(this, facets, enums, finalSet, manager);
}
inline void BooleanDatatypeValidator::validate( const XMLCh* const content)
diff --git a/src/xercesc/validators/datatype/DatatypeValidator.cpp b/src/xercesc/validators/datatype/DatatypeValidator.cpp
index 7da8ee35e84770bcbae9a2534fe8644b5eee3204..1c45cce875bf40924293214c8a3987222b6f272a 100644
--- a/src/xercesc/validators/datatype/DatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/DatatypeValidator.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2003/01/29 19:52:32 gareth
* PSVI API additions.
*
@@ -99,6 +102,7 @@
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/validators/datatype/DatatypeValidator.hpp>
+#include <xercesc/framework/MemoryManager.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -108,8 +112,11 @@ XERCES_CPP_NAMESPACE_BEGIN
DatatypeValidator::DatatypeValidator(DatatypeValidator* const baseValidator,
RefHashTableOf<KVStringPair>* const facets,
const int finalSet,
- const ValidatorType type)
- : fFinalSet(finalSet)
+ const ValidatorType type,
+ MemoryManager* const manager)
+ : fMemoryManager(manager)
+ , fAnonymous(false)
+ , fFinalSet(finalSet)
, fFacetsDefined(0)
, fFixed(0)
, fType(type)
@@ -117,10 +124,9 @@ DatatypeValidator::DatatypeValidator(DatatypeValidator* const baseValidator,
, fFacets(facets)
, fPattern(0)
, fRegex(0)
- , fTypeLocalName(0)
+ , fTypeLocalName(XMLUni::fgZeroLenString)
, fTypeName(0)
- , fTypeUri(0)
- , fAnonymous(false)
+ , fTypeUri(XMLUni::fgZeroLenString)
{
}
@@ -145,6 +151,91 @@ const XMLCh* DatatypeValidator::getWSstring(const short theType) const
}
+void DatatypeValidator::setTypeName(const XMLCh* const name, const XMLCh* const uri)
+{
+ if (fTypeName) {
+
+ fMemoryManager->deallocate(fTypeName);
+ fTypeName = 0;
+ }
+
+ if (name || uri) {
+
+ unsigned int nameLen = XMLString::stringLen(name);
+ unsigned int uriLen = XMLString::stringLen(uri);
+
+ fTypeName = (XMLCh*) fMemoryManager->allocate
+ (
+ (nameLen + uriLen + 2)*sizeof(XMLCh)
+ );
+ fTypeUri = fTypeName;
+ fTypeLocalName = &fTypeName[uriLen+1];
+
+ if (uri)
+ XMLString::moveChars(fTypeName, uri, uriLen+1);
+ else
+ fTypeName[0] = chNull;
+
+ if (name)
+ XMLString::moveChars(&fTypeName[uriLen+1], name, nameLen+1);
+ else
+ fTypeName[uriLen+1] = chNull;
+ }
+ else
+ {
+ fTypeUri = fTypeLocalName = XMLUni::fgZeroLenString;
+ }
+}
+
+void DatatypeValidator::setTypeName(const XMLCh* const typeName)
+{
+ if (fTypeName)
+ {
+ fMemoryManager->deallocate(fTypeName);
+ fTypeName = 0;
+ }
+
+ if (typeName)
+ {
+ unsigned int nameLen = XMLString::stringLen(typeName);
+ int commaOffset = XMLString::indexOf(typeName, chComma);
+
+ fTypeName = (XMLCh*) fMemoryManager->allocate
+ (
+ (nameLen + 1) * sizeof(XMLCh)
+ );
+ XMLString::moveChars(fTypeName, typeName, nameLen+1);
+
+ if ( commaOffset == -1) {
+ fTypeUri = SchemaSymbols::fgURI_SCHEMAFORSCHEMA;
+ fTypeLocalName = fTypeName;
+ }
+ else {
+ fTypeUri = fTypeName;
+ fTypeLocalName = &fTypeName[commaOffset+1];
+ fTypeName[commaOffset] = chNull;
+ }
+ }
+ else
+ {
+ fTypeUri = fTypeLocalName = XMLUni::fgZeroLenString;
+ }
+}
+
+// ---------------------------------------------------------------------------
+// DatatypeValidator: CleanUp methods
+// ---------------------------------------------------------------------------
+void DatatypeValidator::cleanUp() {
+
+ delete fFacets;
+ delete fRegex;
+ if (fPattern)
+ fMemoryManager->deallocate(fPattern);//delete [] fPattern;
+ if (fTypeName)
+ fMemoryManager->deallocate(fTypeName);
+}
+
+
XERCES_CPP_NAMESPACE_END
/**
diff --git a/src/xercesc/validators/datatype/DatatypeValidator.hpp b/src/xercesc/validators/datatype/DatatypeValidator.hpp
index d496db8a5ee37d52afbda61906866bf7650d561b..de24de16b36f06a4aa198caa8ff95924c1aac5f8 100644
--- a/src/xercesc/validators/datatype/DatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/DatatypeValidator.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -61,14 +61,18 @@
#if !defined(DATATYPEVALIDATOR_HPP)
#define DATATYPEVALIDATOR_HPP
+#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/RefHashTableOf.hpp>
#include <xercesc/util/KVStringPair.hpp>
+#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/regx/RegularExpression.hpp>
#include <xercesc/validators/schema/SchemaSymbols.hpp>
-#include <xercesc/framework/XMLBuffer.hpp>
+
XERCES_CPP_NAMESPACE_BEGIN
+class MemoryManager;
+
/**
* DataTypeValidator defines the interface that data type validators must
* obey. These validators can be supplied by the application writer and may
@@ -85,7 +89,7 @@ XERCES_CPP_NAMESPACE_BEGIN
*/
-class VALIDATORS_EXPORT DatatypeValidator
+class VALIDATORS_EXPORT DatatypeValidator : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -269,9 +273,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const,
- RefArrayVectorOf<XMLCh>* const enums,
- const int finalSet) = 0;
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ ) = 0;
/**
* Returns the uri,name of the type this validator is for
@@ -300,6 +308,10 @@ public:
*/
const XMLCh* getTypeLocalName() const;
+ /**
+ * Returns the plugged-in memory manager
+ */
+ MemoryManager* getMemoryManager() const;
protected:
// -----------------------------------------------------------------------
@@ -321,7 +333,8 @@ protected:
DatatypeValidator(DatatypeValidator* const baseValidator,
RefHashTableOf<KVStringPair>* const facets,
const int finalSet,
- const ValidatorType type);
+ const ValidatorType type,
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
//@}
@@ -363,6 +376,14 @@ protected:
*/
const XMLCh* getWSstring(const short WSType) const;
+ // -----------------------------------------------------------------------
+ // Protected data members
+ //
+ // fMemoryManager
+ // Pluggable memory manager for dynamic allocation/deallocation.
+ // -----------------------------------------------------------------------
+ MemoryManager* fMemoryManager;
+
private:
// -----------------------------------------------------------------------
// CleanUp methods
@@ -413,6 +434,7 @@ private:
// true if this type is anonynous
//
// -----------------------------------------------------------------------
+ bool fAnonymous;
int fFinalSet;
int fFacetsDefined;
int fFixed;
@@ -421,10 +443,9 @@ private:
RefHashTableOf<KVStringPair>* fFacets;
XMLCh* fPattern;
RegularExpression* fRegex;
- XMLCh* fTypeLocalName;
XMLCh* fTypeName;
- XMLCh* fTypeUri;
- bool fAnonymous;
+ const XMLCh* fTypeLocalName;
+ const XMLCh* fTypeUri;
};
@@ -456,88 +477,74 @@ inline DatatypeValidator::ValidatorType DatatypeValidator::getType() const
return fType;
}
-inline void DatatypeValidator::setType(ValidatorType theType)
+inline int DatatypeValidator::getFacetsDefined() const
{
- fType = theType;
+ return fFacetsDefined;
}
-// ---------------------------------------------------------------------------
-// DatatypeValidator: CleanUp methods
-// ---------------------------------------------------------------------------
-inline void DatatypeValidator::cleanUp() {
-
- delete fFacets;
- delete [] fPattern;
- delete fRegex;
- delete [] fTypeName;
- delete [] fTypeLocalName;
- delete [] fTypeUri;
+inline int DatatypeValidator::getFixed() const
+{
+ return fFixed;
}
-
-// ---------------------------------------------------------------------------
-// DatatypeValidators: Compare methods
-// ---------------------------------------------------------------------------
-inline int DatatypeValidator::compare(const XMLCh* const lValue,
- const XMLCh* const rValue)
+inline const XMLCh* DatatypeValidator::getPattern() const
{
- return XMLString::compareString(lValue, rValue);
+ return fPattern;
}
-// ---------------------------------------------------------------------------
-// DatatypeValidators: Validation methods
-// ---------------------------------------------------------------------------
-inline bool
-DatatypeValidator::isSubstitutableBy(const DatatypeValidator* const toCheck)
+inline RegularExpression* DatatypeValidator::getRegex() const
{
- const DatatypeValidator* dv = toCheck;
-
- while (dv != 0) {
-
- if (dv == this) {
- return true;
- }
+ return fRegex;
+}
- dv = dv->getBaseValidator();
- }
+inline const XMLCh* DatatypeValidator::getTypeName() const
+{
+ return fTypeLocalName;
+}
- return false;
+inline bool DatatypeValidator::getAnonymous() const
+{
+ return fAnonymous;
}
-inline int DatatypeValidator::getFacetsDefined() const
+inline const XMLCh* DatatypeValidator::getTypeLocalName() const
{
- return fFacetsDefined;
+ return fTypeLocalName;
}
-inline void DatatypeValidator::setFacetsDefined(int facets)
+inline const XMLCh* DatatypeValidator::getTypeUri() const
{
- fFacetsDefined |= facets;
+ return fTypeUri;
}
-inline int DatatypeValidator::getFixed() const
+inline MemoryManager* DatatypeValidator::getMemoryManager() const
{
- return fFixed;
+ return fMemoryManager;
}
-inline void DatatypeValidator::setFixed(int fixed)
+// ---------------------------------------------------------------------------
+// DatatypeValidator: Setters
+// ---------------------------------------------------------------------------
+inline void DatatypeValidator::setType(ValidatorType theType)
{
- fFixed |= fixed;
+ fType = theType;
}
-inline const XMLCh* DatatypeValidator::getPattern() const
+inline void DatatypeValidator::setFacetsDefined(int facets)
{
- return fPattern;
+ fFacetsDefined |= facets;
}
-inline void DatatypeValidator::setPattern(const XMLCh* pattern)
+inline void DatatypeValidator::setFixed(int fixed)
{
- delete [] fPattern;
- fPattern = XMLString::replicate(pattern);
+ fFixed |= fixed;
}
-inline RegularExpression* DatatypeValidator::getRegex() const
+inline void DatatypeValidator::setPattern(const XMLCh* pattern)
{
- return fRegex;
+ if (fPattern)
+ fMemoryManager->deallocate(fPattern);//delete [] fPattern;
+ fPattern = XMLString::replicate(pattern, fMemoryManager);
}
inline void DatatypeValidator::setRegex(RegularExpression* const regex)
@@ -550,75 +557,37 @@ inline bool DatatypeValidator::isAtomic() const {
return true;
}
-inline const XMLCh* DatatypeValidator::getTypeName() const {
- return fTypeName;
-}
-
-inline const XMLCh* DatatypeValidator::getTypeLocalName() const {
- if(!fTypeLocalName) {
- int index = XMLString::indexOf(fTypeName, chComma);
- int length = XMLString::stringLen(fTypeName);
- XMLCh *tName = new XMLCh[length - index + 1];
- XMLString::subString(tName, fTypeName, index + 1, length);
- ((DatatypeValidator *)this)->fTypeLocalName = tName;
- }
-
- return fTypeLocalName;
+inline void DatatypeValidator::setAnonymous() {
+ fAnonymous = true;
}
-inline const XMLCh* DatatypeValidator::getTypeUri() const {
- if(!fTypeUri) {
- int index = XMLString::indexOf(fTypeName, chComma);
- XMLCh *uri = new XMLCh[index + 1];
- XMLString::subString(uri, fTypeName, 0, index);
- ((DatatypeValidator *)this)->fTypeUri = uri;
- }
-
- return fTypeUri;
+// ---------------------------------------------------------------------------
+// DatatypeValidators: Compare methods
+// ---------------------------------------------------------------------------
+inline int DatatypeValidator::compare(const XMLCh* const lValue,
+ const XMLCh* const rValue)
+{
+ return XMLString::compareString(lValue, rValue);
}
-inline void DatatypeValidator::setTypeName(const XMLCh* const name, const XMLCh* const uri) {
+// ---------------------------------------------------------------------------
+// DatatypeValidators: Validation methods
+// ---------------------------------------------------------------------------
+inline bool
+DatatypeValidator::isSubstitutableBy(const DatatypeValidator* const toCheck)
+{
+ const DatatypeValidator* dv = toCheck;
- delete [] fTypeName;
- delete [] fTypeLocalName;
- delete [] fTypeUri;
+ while (dv != 0) {
- fTypeUri = XMLString::replicate(uri);
- fTypeLocalName = XMLString::replicate(name);
- XMLBuffer buf;
- buf.set(uri);
- buf.append(chComma);
- buf.append(name);
- fTypeName = XMLString::replicate(buf.getRawBuffer());
-}
+ if (dv == this) {
+ return true;
+ }
-inline void DatatypeValidator::setTypeName(const XMLCh* const typeName) {
-
- delete [] fTypeName;
- delete [] fTypeLocalName;
- fTypeLocalName = 0;
- delete [] fTypeUri;
- fTypeUri = 0;
-
- //REVISIT this is a lot of work, cant we set this earlier when we have the info?
- if( XMLString::indexOf( typeName, chComma ) < 0 ) {
- XMLBuffer buf;
- buf.set(SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
- buf.append(chComma);
- buf.append(typeName);
- fTypeName = XMLString::replicate(buf.getRawBuffer());
- }
- else {
- fTypeName = XMLString::replicate(typeName);
+ dv = dv->getBaseValidator();
}
-}
-inline void DatatypeValidator::setAnonymous() {
- fAnonymous = true;
-}
-
-inline bool DatatypeValidator::getAnonymous() const {
- return fAnonymous;
+ return false;
}
diff --git a/src/xercesc/validators/datatype/DatatypeValidatorFactory.cpp b/src/xercesc/validators/datatype/DatatypeValidatorFactory.cpp
index 2039ad94b91c1b057c3be9f88b44d710e76d51e9..fc274a95981d6284e91802203a0b2a3af6c97b55 100644
--- a/src/xercesc/validators/datatype/DatatypeValidatorFactory.cpp
+++ b/src/xercesc/validators/datatype/DatatypeValidatorFactory.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.14 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.13 2003/03/18 19:42:17 knoaman
* Schema Errata E2-18.
*
@@ -383,8 +386,9 @@ RefHashTableOf<DatatypeValidator>* DatatypeValidatorFactory::fBuiltInRegistry =
// ---------------------------------------------------------------------------
// DatatypeValidatorFactory: Constructors and Destructor
// ---------------------------------------------------------------------------
-DatatypeValidatorFactory::DatatypeValidatorFactory()
+DatatypeValidatorFactory::DatatypeValidatorFactory(MemoryManager* const manager)
: fUserDefinedRegistry(0)
+ , fMemoryManager(manager)
{
}
@@ -718,29 +722,43 @@ void DatatypeValidatorFactory::expandRegistryToFullSchemaSet()
// So instead of storing them in the static fBuiltInRegistry,
// store them in local data fUserDefinedRegistry
if (fUserDefinedRegistry == 0)
- fUserDefinedRegistry = new RefHashTableOf<DatatypeValidator>(29);
+ fUserDefinedRegistry = new (fMemoryManager) RefHashTableOf<DatatypeValidator>(29);
if (!getDatatypeValidator(XMLUni::fgIDRefsString)) {
- DatatypeValidator *dv = new IDDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
+ DatatypeValidator *dv = new (fMemoryManager) IDDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
dv->setTypeName(XMLUni::fgIDString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fUserDefinedRegistry->put((void*) XMLUni::fgIDString, dv);
- dv = new IDREFDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
+ dv = new (fMemoryManager) IDREFDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
dv->setTypeName(XMLUni::fgIDRefString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fUserDefinedRegistry->put((void*) XMLUni::fgIDRefString, dv);
- dv = new ENTITYDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
+ dv = new (fMemoryManager) ENTITYDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
dv->setTypeName(XMLUni::fgEntityString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fUserDefinedRegistry->put((void*) XMLUni::fgEntityString, dv);
// Create 'IDREFS' datatype validator
- createDatatypeValidator(XMLUni::fgIDRefsString,
- getDatatypeValidator(XMLUni::fgIDRefString), 0, 0, true, 0, true);
+ createDatatypeValidator
+ (
+ XMLUni::fgIDRefsString
+ , getDatatypeValidator(XMLUni::fgIDRefString)
+ , 0
+ , 0
+ , true
+ , 0
+ );
// Create 'ENTITIES' datatype validator
- createDatatypeValidator(XMLUni::fgEntitiesString,
- getDatatypeValidator(XMLUni::fgEntityString), 0, 0, true, 0, true);
+ createDatatypeValidator
+ (
+ XMLUni::fgEntitiesString
+ , getDatatypeValidator(XMLUni::fgEntityString)
+ , 0
+ , 0
+ , true
+ , 0
+ );
}
}
@@ -748,14 +766,16 @@ void DatatypeValidatorFactory::expandRegistryToFullSchemaSet()
// ---------------------------------------------------------------------------
// DatatypeValidatorFactory: factory methods
// ---------------------------------------------------------------------------
-DatatypeValidator*
-DatatypeValidatorFactory::createDatatypeValidator(const XMLCh* const typeName,
- DatatypeValidator* const baseValidator,
- RefHashTableOf<KVStringPair>* const facets,
- RefArrayVectorOf<XMLCh>* const enums,
- const bool derivedByList,
- const int finalSet,
- const bool userDefined)
+DatatypeValidator* DatatypeValidatorFactory::createDatatypeValidator
+(
+ const XMLCh* const typeName
+ , DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const bool isDerivedByList
+ , const int finalSet
+ , const bool isUserDefined
+)
{
if (baseValidator == 0) {
@@ -771,9 +791,11 @@ DatatypeValidatorFactory::createDatatypeValidator(const XMLCh* const typeName,
}
DatatypeValidator* datatypeValidator = 0;
+ MemoryManager* const manager = (isUserDefined)
+ ? fMemoryManager : XMLPlatformUtils::fgMemoryManager;
- if (derivedByList) {
- datatypeValidator = new ListDatatypeValidator(baseValidator, facets, enums, finalSet);
+ if (isDerivedByList) {
+ datatypeValidator = new (manager) ListDatatypeValidator(baseValidator, facets, enums, finalSet);
}
else {
@@ -786,15 +808,21 @@ DatatypeValidatorFactory::createDatatypeValidator(const XMLCh* const typeName,
}
}
- datatypeValidator = baseValidator->newInstance(facets, enums, finalSet);
+ datatypeValidator = baseValidator->newInstance
+ (
+ facets
+ , enums
+ , finalSet
+ , manager
+ );
}
if (datatypeValidator != 0) {
- if (userDefined) {
+ if (isUserDefined) {
if (!fUserDefinedRegistry) {
- fUserDefinedRegistry = new RefHashTableOf<DatatypeValidator>(29);
+ fUserDefinedRegistry = new (fMemoryManager) RefHashTableOf<DatatypeValidator>(29);
}
fUserDefinedRegistry->put((void *)typeName, datatypeValidator);
@@ -802,6 +830,7 @@ DatatypeValidatorFactory::createDatatypeValidator(const XMLCh* const typeName,
else {
fBuiltInRegistry->put((void *)typeName, datatypeValidator);
}
+
datatypeValidator->setTypeName(typeName);
}
@@ -809,25 +838,29 @@ DatatypeValidatorFactory::createDatatypeValidator(const XMLCh* const typeName,
}
-DatatypeValidator*
-DatatypeValidatorFactory::createDatatypeValidator(const XMLCh* const typeName,
- RefVectorOf<DatatypeValidator>* const validators,
- const int finalSet,
- const bool userDefined)
+DatatypeValidator* DatatypeValidatorFactory::createDatatypeValidator
+(
+ const XMLCh* const typeName
+ , RefVectorOf<DatatypeValidator>* const validators
+ , const int finalSet
+ , const bool userDefined
+)
{
if (validators == 0)
return 0;
DatatypeValidator* datatypeValidator = 0;
+ MemoryManager* const manager = (userDefined)
+ ? fMemoryManager : XMLPlatformUtils::fgMemoryManager;
- datatypeValidator = new UnionDatatypeValidator(validators, finalSet);
+ datatypeValidator = new (manager) UnionDatatypeValidator(validators, finalSet);
if (datatypeValidator != 0) {
if (userDefined) {
if (!fUserDefinedRegistry) {
- fUserDefinedRegistry = new RefHashTableOf<DatatypeValidator>(29);
+ fUserDefinedRegistry = new (fMemoryManager) RefHashTableOf<DatatypeValidator>(29);
}
fUserDefinedRegistry->put((void *)typeName, datatypeValidator);
diff --git a/src/xercesc/validators/datatype/DatatypeValidatorFactory.hpp b/src/xercesc/validators/datatype/DatatypeValidatorFactory.hpp
index 989df51bf1be2b597dd1c9155adbc9a8ee387e3b..b69916e5470e6252289d6ee1d52148c4c17b834a 100644
--- a/src/xercesc/validators/datatype/DatatypeValidatorFactory.hpp
+++ b/src/xercesc/validators/datatype/DatatypeValidatorFactory.hpp
@@ -97,7 +97,7 @@ typedef RefHashTableOf<DatatypeValidator> DVHashTable;
typedef RefArrayVectorOf<XMLCh> XMLChRefVector;
-class VALIDATORS_EXPORT DatatypeValidatorFactory
+class VALIDATORS_EXPORT DatatypeValidatorFactory : public XMemory
{
public:
@@ -107,7 +107,10 @@ public:
/** @name Constructors */
//@{
- DatatypeValidatorFactory();
+ DatatypeValidatorFactory
+ (
+ MemoryManager* const manager// = XMLPlatformUtils::fgMemoryManager
+ );
//@}
@@ -174,40 +177,53 @@ public:
* Creates a new datatype validator of type baseValidator's class and
* adds it to the registry
*
- * @param typeName Datatype validator name
+ * @param typeName Datatype validator name
*
- * @param baseValidator Base datatype validator
+ * @param baseValidator Base datatype validator
*
- * @param facets datatype facets if any
+ * @param facets datatype facets if any
*
- * @param enums vector of values for enum facet
+ * @param enums vector of values for enum facet
*
- * @param derivedByList Indicates whether the datatype is derived by
- * list or not
+ * @param isDerivedByList Indicates whether the datatype is derived by
+ * list or not
*
* @param finalSet 'final' values of the simpleType
+ *
+ * @param isUserDefined Indicates whether the datatype is built-in or
+ * user defined
*/
- DatatypeValidator* createDatatypeValidator(const XMLCh* const,
- DatatypeValidator* const,
- RefHashTableOf<KVStringPair>* const,
- RefArrayVectorOf<XMLCh>* const enums,
- const bool,
- const int = 0,
- const bool = true);
+ DatatypeValidator* createDatatypeValidator
+ (
+ const XMLCh* const typeName
+ , DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const bool isDerivedByList
+ , const int finalSet = 0
+ , const bool isUserDefined = true
+ );
/**
- * Creates a new datatype validator of type UnionDatatypeValidator and
- * adds it to the registry
- *
- * @param typeName Datatype validator name
- *
- * @param validators Vector of datatype validators
- *
- */
- DatatypeValidator* createDatatypeValidator(const XMLCh* const,
- RefVectorOf<DatatypeValidator>* const,
- const int finalSet,
- const bool = true);
+ * Creates a new datatype validator of type UnionDatatypeValidator and
+ * adds it to the registry
+ *
+ * @param typeName Datatype validator name
+ *
+ * @param validators Vector of datatype validators
+ *
+ * @param finalSet 'final' values of the simpleType
+ *
+ * @param isUserDefined Indicates whether the datatype is built-in or
+ * user defined
+ */
+ DatatypeValidator* createDatatypeValidator
+ (
+ const XMLCh* const typeName
+ , RefVectorOf<DatatypeValidator>* const validators
+ , const int finalSet
+ , const bool isUserDefined = true
+ );
//@}
@@ -238,6 +254,7 @@ private:
// -----------------------------------------------------------------------
XERCES_CPP_NAMESPACE_QUALIFIER RefHashTableOf<XERCES_CPP_NAMESPACE_QUALIFIER DatatypeValidator>* fUserDefinedRegistry;
static XERCES_CPP_NAMESPACE_QUALIFIER RefHashTableOf<DatatypeValidator>* fBuiltInRegistry;
+ XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* const fMemoryManager;
friend class XPath2ContextImpl;
};
diff --git a/src/xercesc/validators/datatype/DateDatatypeValidator.cpp b/src/xercesc/validators/datatype/DateDatatypeValidator.cpp
index 69ce0eea5de0ec31636dc9e4f987344b7371a611..1fb7d367a792c96e396f308f841823fe98ed83f5 100644
--- a/src/xercesc/validators/datatype/DateDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/DateDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-DateDatatypeValidator::DateDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::Date)
+DateDatatypeValidator::DateDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::Date, manager)
{}
DateDatatypeValidator::DateDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Date)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Date, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ DateDatatypeValidator::DateDatatypeValidator(
DateDatatypeValidator::~DateDatatypeValidator()
{}
-DatatypeValidator* DateDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* DateDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new DateDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) DateDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* DateDatatypeValidator::newInstance(
//
XMLDateTime* DateDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/DateDatatypeValidator.hpp b/src/xercesc/validators/datatype/DateDatatypeValidator.hpp
index 6522c2de7dc77dec015e7951a078fd5555f83b14..e1c71ea5297619a3b124bb48ab9cbc50336fc0df 100644
--- a/src/xercesc/validators/datatype/DateDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/DateDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -85,28 +88,36 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- DateDatatypeValidator();
-
- DateDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ DateDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ DateDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~DateDatatypeValidator();
-
//@}
/**
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/DateTimeDatatypeValidator.cpp b/src/xercesc/validators/datatype/DateTimeDatatypeValidator.cpp
index 0f519f8f3188519dcd080796e8ea9ce8d75955ed..851139108b03bb64318f2c7841b245384d25b3f9 100644
--- a/src/xercesc/validators/datatype/DateTimeDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/DateTimeDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-DateTimeDatatypeValidator::DateTimeDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::DateTime)
+DateTimeDatatypeValidator::DateTimeDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::DateTime, manager)
{}
DateTimeDatatypeValidator::DateTimeDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::DateTime)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::DateTime, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ DateTimeDatatypeValidator::DateTimeDatatypeValidator(
DateTimeDatatypeValidator::~DateTimeDatatypeValidator()
{}
-DatatypeValidator* DateTimeDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* DateTimeDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new DateTimeDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) DateTimeDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* DateTimeDatatypeValidator::newInstance(
//
XMLDateTime* DateTimeDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/DateTimeDatatypeValidator.hpp b/src/xercesc/validators/datatype/DateTimeDatatypeValidator.hpp
index e12473b15b5fd610b410632fd4ed3ab9c6054da7..b2a60204519aa627c59af6e4113f7ccd0942801c 100644
--- a/src/xercesc/validators/datatype/DateTimeDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/DateTimeDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -85,28 +88,36 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- DateTimeDatatypeValidator();
-
- DateTimeDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ DateTimeDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ DateTimeDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~DateTimeDatatypeValidator();
-
//@}
/**
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/DateTimeValidator.cpp b/src/xercesc/validators/datatype/DateTimeValidator.cpp
index 4cb2faeb07bbb894dbd820e82f6a4cdc9d1c3238..0994dae0914f37a1d4a1e43720f22f678d7f96cd 100644
--- a/src/xercesc/validators/datatype/DateTimeValidator.cpp
+++ b/src/xercesc/validators/datatype/DateTimeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.5 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2003/01/30 21:56:22 tng
* Performance: call getRawData instead of toString
*
@@ -111,8 +114,9 @@ DateTimeValidator::DateTimeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:AbstractNumericFacetValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:AbstractNumericFacetValidator(baseValidator, facets, finalSet, type, manager)
{
//do not invoke init() here !!!
}
@@ -175,7 +179,7 @@ void DateTimeValidator::checkContent(const XMLCh* const content
// lazy construction
if (getRegex() ==0) {
try {
- setRegex(new RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
+ setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
}
catch (XMLException &e)
{
@@ -341,7 +345,7 @@ void DateTimeValidator::setEnumeration()
return;
int enumLength = fStrEnumeration->size();
- fEnumeration = new RefVectorOf<XMLNumber>(enumLength, true);
+ fEnumeration = new (fMemoryManager) RefVectorOf<XMLNumber>(enumLength, true);
fEnumerationInherited = false;
for ( int i = 0; i < enumLength; i++)
diff --git a/src/xercesc/validators/datatype/DateTimeValidator.hpp b/src/xercesc/validators/datatype/DateTimeValidator.hpp
index 27c55792c87d0deeff7d6d98a8a05e0d2121b039..7d4bfe266110cccc47d9b1fc48ce387b60289b15 100644
--- a/src/xercesc/validators/datatype/DateTimeValidator.hpp
+++ b/src/xercesc/validators/datatype/DateTimeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.3 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:53:28 tng
* C++ Namespace Support.
*
@@ -103,10 +106,14 @@ protected:
// -----------------------------------------------------------------------
// ctor used by derived class
// -----------------------------------------------------------------------
- DateTimeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ DateTimeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
//
// Abstract interface
diff --git a/src/xercesc/validators/datatype/DayDatatypeValidator.cpp b/src/xercesc/validators/datatype/DayDatatypeValidator.cpp
index f93d11ef66eb1015edeeebcd4b043ae64d245a2f..bc3c467f42db4a717deec1e85e1bd9c39efc1ff1 100644
--- a/src/xercesc/validators/datatype/DayDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/DayDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-DayDatatypeValidator::DayDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::Day)
+DayDatatypeValidator::DayDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::Day, manager)
{}
DayDatatypeValidator::DayDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Day)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Day, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ DayDatatypeValidator::DayDatatypeValidator(
DayDatatypeValidator::~DayDatatypeValidator()
{}
-DatatypeValidator* DayDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* DayDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new DayDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) DayDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* DayDatatypeValidator::newInstance(
//
XMLDateTime* DayDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/DayDatatypeValidator.hpp b/src/xercesc/validators/datatype/DayDatatypeValidator.hpp
index eb270f04b6c463008618ac85fb6d4d2524eef68a..24644bc53aff847dc33b82bf063ac77a34498b0a 100644
--- a/src/xercesc/validators/datatype/DayDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/DayDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -85,16 +88,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor*/
//@{
- DayDatatypeValidator();
-
- DayDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ DayDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ DayDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~DayDatatypeValidator();
//@}
@@ -103,9 +111,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/DecimalDatatypeValidator.cpp b/src/xercesc/validators/datatype/DecimalDatatypeValidator.cpp
index 1edccb57161b5ccf5cf93951069f15601abb60b0..101b1be5908f814353adba7b0bbc878bb52466ae 100644
--- a/src/xercesc/validators/datatype/DecimalDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/DecimalDatatypeValidator.cpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.9 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.8 2003/03/01 20:59:06 peiyongz
* TotalDigits value must be a positiveInteger
*
@@ -145,6 +148,7 @@
#include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
#include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
#include <xercesc/util/NumberFormatException.hpp>
+#include <xercesc/util/XMLBigDecimal.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -155,8 +159,8 @@ static XMLCh value2[BUF_LEN+1];
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-DecimalDatatypeValidator::DecimalDatatypeValidator()
-:AbstractNumericValidator(0, 0, 0, DatatypeValidator::Decimal)
+DecimalDatatypeValidator::DecimalDatatypeValidator(MemoryManager* const manager)
+:AbstractNumericValidator(0, 0, 0, DatatypeValidator::Decimal, manager)
, fTotalDigits(0)
, fFractionDigits(0)
{}
@@ -165,8 +169,9 @@ DecimalDatatypeValidator::DecimalDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Decimal)
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Decimal, manager)
, fTotalDigits(0)
, fFractionDigits(0)
{
@@ -182,20 +187,21 @@ DecimalDatatypeValidator::~DecimalDatatypeValidator()
int DecimalDatatypeValidator::compare(const XMLCh* const lValue
, const XMLCh* const rValue)
{
- XMLBigDecimal * lObj = new XMLBigDecimal(lValue);
- Janitor<XMLBigDecimal> jname1(lObj);
- XMLBigDecimal * rObj = new XMLBigDecimal(rValue);
- Janitor<XMLBigDecimal> jname2(rObj);
+ XMLBigDecimal lObj(lValue);
+ XMLBigDecimal rObj(rValue);
- return compareValues(lObj, rObj);
+ return compareValues(&lObj, &rObj);
}
-DatatypeValidator* DecimalDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* DecimalDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new DecimalDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) DecimalDatatypeValidator(this, facets, enums, finalSet, manager);
}
// -----------------------------------------------------------------------
@@ -204,8 +210,9 @@ DatatypeValidator* DecimalDatatypeValidator::newInstance(
DecimalDatatypeValidator::DecimalDatatypeValidator(DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:AbstractNumericValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:AbstractNumericValidator(baseValidator, facets, finalSet, type, manager)
, fTotalDigits(0)
, fFractionDigits(0)
{
@@ -399,22 +406,22 @@ int DecimalDatatypeValidator::compareValues(const XMLNumber* const lValue
void DecimalDatatypeValidator::setMaxInclusive(const XMLCh* const value)
{
- fMaxInclusive = new XMLBigDecimal(value);
+ fMaxInclusive = new (fMemoryManager) XMLBigDecimal(value);
}
void DecimalDatatypeValidator::setMaxExclusive(const XMLCh* const value)
{
- fMaxExclusive = new XMLBigDecimal(value);
+ fMaxExclusive = new (fMemoryManager) XMLBigDecimal(value);
}
void DecimalDatatypeValidator::setMinInclusive(const XMLCh* const value)
{
- fMinInclusive = new XMLBigDecimal(value);
+ fMinInclusive = new (fMemoryManager) XMLBigDecimal(value);
}
void DecimalDatatypeValidator::setMinExclusive(const XMLCh* const value)
{
- fMinExclusive = new XMLBigDecimal(value);
+ fMinExclusive = new (fMemoryManager) XMLBigDecimal(value);
}
void DecimalDatatypeValidator::setEnumeration()
@@ -456,12 +463,12 @@ void DecimalDatatypeValidator::setEnumeration()
checkContent(fStrEnumeration->elementAt(i), false);
}
- fEnumeration = new RefVectorOf<XMLNumber>(enumLength, true);
+ fEnumeration = new (fMemoryManager) RefVectorOf<XMLNumber>(enumLength, true);
fEnumerationInherited = false;
for ( i = 0; i < enumLength; i++)
{
- fEnumeration->insertElementAt(new XMLBigDecimal(fStrEnumeration->elementAt(i)), i);
+ fEnumeration->insertElementAt(new (fMemoryManager) XMLBigDecimal(fStrEnumeration->elementAt(i)), i);
}
}
@@ -485,7 +492,7 @@ void DecimalDatatypeValidator::checkContent( const XMLCh* const content, bool as
// lazy construction
if (getRegex() ==0) {
try {
- setRegex(new RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
+ setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
}
catch (XMLException &e)
{
diff --git a/src/xercesc/validators/datatype/DecimalDatatypeValidator.hpp b/src/xercesc/validators/datatype/DecimalDatatypeValidator.hpp
index 663ad3918a40deccea5616708d3412d916db3a3d..18ec4755df0653157817da6d547404d32f191603 100644
--- a/src/xercesc/validators/datatype/DecimalDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/DecimalDatatypeValidator.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.5 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -88,7 +91,6 @@
#include <xercesc/validators/datatype/AbstractNumericValidator.hpp>
#include <xercesc/util/RefVectorOf.hpp>
-#include <xercesc/util/XMLBigDecimal.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -99,16 +101,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- DecimalDatatypeValidator();
-
- DecimalDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ DecimalDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ DecimalDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~DecimalDatatypeValidator();
//@}
@@ -134,19 +141,27 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
// -----------------------------------------------------------------------
// ctor provided to be used by derived classes
// -----------------------------------------------------------------------
- DecimalDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ DecimalDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager
+ );
// -----------------------------------------------------------------------
// Abstract interface from AbstractNumericFacetValidator
diff --git a/src/xercesc/validators/datatype/DoubleDatatypeValidator.cpp b/src/xercesc/validators/datatype/DoubleDatatypeValidator.cpp
index 3326107ecd2d2ab601eac33c41b5a1b58ce643c1..c6011482d6c352781d0e277f52de388d6ce6e1e0 100644
--- a/src/xercesc/validators/datatype/DoubleDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/DoubleDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -91,7 +94,6 @@
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/validators/datatype/DoubleDatatypeValidator.hpp>
-#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/validators/datatype/InvalidDatatypeFacetException.hpp>
#include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
@@ -100,16 +102,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-DoubleDatatypeValidator::DoubleDatatypeValidator()
-:AbstractNumericValidator(0, 0, 0, DatatypeValidator::Double)
+DoubleDatatypeValidator::DoubleDatatypeValidator(MemoryManager* const manager)
+:AbstractNumericValidator(0, 0, 0, DatatypeValidator::Double, manager)
{}
DoubleDatatypeValidator::DoubleDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Double)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Double, manager)
{
init(enums);
}
@@ -123,20 +126,21 @@ DoubleDatatypeValidator::~DoubleDatatypeValidator()
int DoubleDatatypeValidator::compare(const XMLCh* const lValue
, const XMLCh* const rValue)
{
- XMLDouble * lObj = new XMLDouble(lValue);
- Janitor<XMLDouble> jname1(lObj);
- XMLDouble * rObj = new XMLDouble(rValue);
- Janitor<XMLDouble> jname2(rObj);
+ XMLDouble lObj(lValue);
+ XMLDouble rObj(rValue);
- return compareValues(lObj, rObj);
+ return compareValues(&lObj, &rObj);
}
-DatatypeValidator* DoubleDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* DoubleDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new DoubleDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) DoubleDatatypeValidator(this, facets, enums, finalSet, manager);
}
// -----------------------------------------------------------------------
@@ -145,8 +149,9 @@ DatatypeValidator* DoubleDatatypeValidator::newInstance(
DoubleDatatypeValidator::DoubleDatatypeValidator(DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:AbstractNumericValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:AbstractNumericValidator(baseValidator, facets, finalSet, type, manager)
{
//do not invoke init here !!!
}
@@ -176,22 +181,22 @@ int DoubleDatatypeValidator::compareValues(const XMLNumber* const lValue
void DoubleDatatypeValidator::setMaxInclusive(const XMLCh* const value)
{
- fMaxInclusive = new XMLDouble(value);
+ fMaxInclusive = new (fMemoryManager) XMLDouble(value);
}
void DoubleDatatypeValidator::setMaxExclusive(const XMLCh* const value)
{
- fMaxExclusive = new XMLDouble(value);
+ fMaxExclusive = new (fMemoryManager) XMLDouble(value);
}
void DoubleDatatypeValidator::setMinInclusive(const XMLCh* const value)
{
- fMinInclusive = new XMLDouble(value);
+ fMinInclusive = new (fMemoryManager) XMLDouble(value);
}
void DoubleDatatypeValidator::setMinExclusive(const XMLCh* const value)
{
- fMinExclusive = new XMLDouble(value);
+ fMinExclusive = new (fMemoryManager) XMLDouble(value);
}
void DoubleDatatypeValidator::setEnumeration()
@@ -234,12 +239,12 @@ void DoubleDatatypeValidator::setEnumeration()
checkContent(fStrEnumeration->elementAt(i), false);
}
- fEnumeration = new RefVectorOf<XMLNumber>(enumLength, true);
+ fEnumeration = new (fMemoryManager) RefVectorOf<XMLNumber>(enumLength, true);
fEnumerationInherited = false;
for ( i = 0; i < enumLength; i++)
{
- fEnumeration->insertElementAt(new XMLDouble(fStrEnumeration->elementAt(i)), i);
+ fEnumeration->insertElementAt(new (fMemoryManager) XMLDouble(fStrEnumeration->elementAt(i)), i);
}
}
@@ -261,7 +266,7 @@ void DoubleDatatypeValidator::checkContent( const XMLCh* const content, bool asB
// lazy construction
if (getRegex() ==0) {
try {
- setRegex(new RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
+ setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
}
catch (XMLException &e)
{
diff --git a/src/xercesc/validators/datatype/DoubleDatatypeValidator.hpp b/src/xercesc/validators/datatype/DoubleDatatypeValidator.hpp
index 5342594d1c7c5f78ca8785a3906d099ae796d780..5b6fcaac3e869cbcc264f08c29f6b280c69de6cd 100644
--- a/src/xercesc/validators/datatype/DoubleDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/DoubleDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -101,16 +104,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- DoubleDatatypeValidator();
-
- DoubleDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ DoubleDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ DoubleDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~DoubleDatatypeValidator();
//@}
@@ -136,19 +144,27 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
// -----------------------------------------------------------------------
// ctor provided to be used by derived classes
// -----------------------------------------------------------------------
- DoubleDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ DoubleDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
// -----------------------------------------------------------------------
// Abstract interface from AbstractNumericFacetValidator
diff --git a/src/xercesc/validators/datatype/DurationDatatypeValidator.cpp b/src/xercesc/validators/datatype/DurationDatatypeValidator.cpp
index 1288a009b0ea5cdba460d3b09b4bec517a2f6a82..5a71573e867b994fd45d5c405ccc7ab2f32124ec 100644
--- a/src/xercesc/validators/datatype/DurationDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/DurationDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-DurationDatatypeValidator::DurationDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::Duration)
+DurationDatatypeValidator::DurationDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::Duration, manager)
{}
DurationDatatypeValidator::DurationDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Duration)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Duration, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ DurationDatatypeValidator::DurationDatatypeValidator(
DurationDatatypeValidator::~DurationDatatypeValidator()
{}
-DatatypeValidator* DurationDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* DurationDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new DurationDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) DurationDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* DurationDatatypeValidator::newInstance(
//
XMLDateTime* DurationDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/DurationDatatypeValidator.hpp b/src/xercesc/validators/datatype/DurationDatatypeValidator.hpp
index e411e9b20d64801bc6c41d687d74829d0206713e..744efc08e1641065f8f14c31f0947977faca5ba9 100644
--- a/src/xercesc/validators/datatype/DurationDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/DurationDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -85,28 +88,36 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor. */
//@{
- DurationDatatypeValidator();
-
- DurationDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ DurationDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ DurationDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~DurationDatatypeValidator();
-
//@}
/**
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/ENTITYDatatypeValidator.cpp b/src/xercesc/validators/datatype/ENTITYDatatypeValidator.cpp
index aa3d3f4e1144bfc4d55d4e4e82c1a1e273b48167..43a45ef294424e05386d8d038ed94027c4afbe03 100644
--- a/src/xercesc/validators/datatype/ENTITYDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/ENTITYDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.6 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2003/01/06 19:40:05 knoaman
* Throw an invalid datatype value exception if fEntityDeclPool is NULL.
*
@@ -107,17 +110,18 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-ENTITYDatatypeValidator::ENTITYDatatypeValidator()
-:StringDatatypeValidator(0, 0, 0, DatatypeValidator::ENTITY)
+ENTITYDatatypeValidator::ENTITYDatatypeValidator(MemoryManager* const manager)
+:StringDatatypeValidator(0, 0, 0, DatatypeValidator::ENTITY, manager)
,fEntityDeclPool(0)
{}
ENTITYDatatypeValidator::ENTITYDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::ENTITY)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::ENTITY, manager)
,fEntityDeclPool(0)
{
init(enums);
@@ -126,12 +130,15 @@ ENTITYDatatypeValidator::ENTITYDatatypeValidator(
ENTITYDatatypeValidator::~ENTITYDatatypeValidator()
{}
-DatatypeValidator* ENTITYDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* ENTITYDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new ENTITYDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) ENTITYDatatypeValidator(this, facets, enums, finalSet, manager);
}
// -----------------------------------------------------------------------
diff --git a/src/xercesc/validators/datatype/ENTITYDatatypeValidator.hpp b/src/xercesc/validators/datatype/ENTITYDatatypeValidator.hpp
index 636fc3ffba4e1b9570a3a12f50a755fcbb8d2afa..e3435478964fcb9b5030d9ad6bb9c5b1c45c167b 100644
--- a/src/xercesc/validators/datatype/ENTITYDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/ENTITYDatatypeValidator.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -94,7 +97,8 @@
#define ENTITY_DATATYPEVALIDATOR_HPP
#include <xercesc/validators/datatype/StringDatatypeValidator.hpp>
-#include <xercesc/internal/XMLScanner.hpp>
+#include <xercesc/util/NameIdPool.hpp>
+#include <xercesc/validators/DTD/DTDEntityDecl.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -105,15 +109,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor. */
//@{
- ENTITYDatatypeValidator();
-
- ENTITYDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ ENTITYDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ ENTITYDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~ENTITYDatatypeValidator();
@@ -158,9 +168,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
// -----------------------------------------------------------------------
// Setter methods
diff --git a/src/xercesc/validators/datatype/FloatDatatypeValidator.cpp b/src/xercesc/validators/datatype/FloatDatatypeValidator.cpp
index 0956a7400cf40bc1d7fb330b46efd5a79d700393..263df44a99858752e22f2a22f5ebcfdfd0fcf227 100644
--- a/src/xercesc/validators/datatype/FloatDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/FloatDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -101,16 +104,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-FloatDatatypeValidator::FloatDatatypeValidator()
-:AbstractNumericValidator(0, 0, 0, DatatypeValidator::Float)
+FloatDatatypeValidator::FloatDatatypeValidator(MemoryManager* const manager)
+:AbstractNumericValidator(0, 0, 0, DatatypeValidator::Float, manager)
{}
FloatDatatypeValidator::FloatDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Float)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractNumericValidator(baseValidator, facets, finalSet, DatatypeValidator::Float, manager)
{
init(enums);
}
@@ -124,20 +128,21 @@ FloatDatatypeValidator::~FloatDatatypeValidator()
int FloatDatatypeValidator::compare(const XMLCh* const lValue
, const XMLCh* const rValue)
{
- XMLFloat * lObj = new XMLFloat(lValue);
- Janitor<XMLFloat> jname1(lObj);
- XMLFloat * rObj = new XMLFloat(rValue);
- Janitor<XMLFloat> jname2(rObj);
+ XMLFloat lObj(lValue);
+ XMLFloat rObj(rValue);
- return compareValues(lObj, rObj);
+ return compareValues(&lObj, &rObj);
}
-DatatypeValidator* FloatDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* FloatDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new FloatDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) FloatDatatypeValidator(this, facets, enums, finalSet, manager);
}
// -----------------------------------------------------------------------
@@ -146,8 +151,9 @@ DatatypeValidator* FloatDatatypeValidator::newInstance(
FloatDatatypeValidator::FloatDatatypeValidator(DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:AbstractNumericValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:AbstractNumericValidator(baseValidator, facets, finalSet, type, manager)
{
//do not invoke init here !!!
}
@@ -177,22 +183,22 @@ int FloatDatatypeValidator::compareValues(const XMLNumber* const lValue
void FloatDatatypeValidator::setMaxInclusive(const XMLCh* const value)
{
- fMaxInclusive = new XMLFloat(value);
+ fMaxInclusive = new (fMemoryManager) XMLFloat(value);
}
void FloatDatatypeValidator::setMaxExclusive(const XMLCh* const value)
{
- fMaxExclusive = new XMLFloat(value);
+ fMaxExclusive = new (fMemoryManager) XMLFloat(value);
}
void FloatDatatypeValidator::setMinInclusive(const XMLCh* const value)
{
- fMinInclusive = new XMLFloat(value);
+ fMinInclusive = new (fMemoryManager) XMLFloat(value);
}
void FloatDatatypeValidator::setMinExclusive(const XMLCh* const value)
{
- fMinExclusive = new XMLFloat(value);
+ fMinExclusive = new (fMemoryManager) XMLFloat(value);
}
void FloatDatatypeValidator::setEnumeration()
@@ -235,12 +241,12 @@ void FloatDatatypeValidator::setEnumeration()
checkContent(fStrEnumeration->elementAt(i), false);
}
- fEnumeration = new RefVectorOf<XMLNumber>(enumLength, true);
+ fEnumeration = new (fMemoryManager) RefVectorOf<XMLNumber>(enumLength, true);
fEnumerationInherited = false;
for ( i = 0; i < enumLength; i++)
{
- fEnumeration->insertElementAt(new XMLFloat(fStrEnumeration->elementAt(i)), i);
+ fEnumeration->insertElementAt(new (fMemoryManager) XMLFloat(fStrEnumeration->elementAt(i)), i);
}
}
@@ -261,7 +267,7 @@ void FloatDatatypeValidator::checkContent( const XMLCh* const content, bool asBa
// lazy construction
if (getRegex() ==0) {
try {
- setRegex(new RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
+ setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
}
catch (XMLException &e)
{
diff --git a/src/xercesc/validators/datatype/FloatDatatypeValidator.hpp b/src/xercesc/validators/datatype/FloatDatatypeValidator.hpp
index 28f58f6fff9f5e90fd567765f569aae1ed0c03a1..9079d0a27aa147c55d644931bd4ba72a26278559 100644
--- a/src/xercesc/validators/datatype/FloatDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/FloatDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -102,16 +105,20 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
-
- FloatDatatypeValidator();
-
- FloatDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ FloatDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ FloatDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~FloatDatatypeValidator();
//@}
@@ -137,23 +144,31 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
-// -----------------------------------------------------------------------
-// ctor provided to be used by derived classes
-// -----------------------------------------------------------------------
- FloatDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ // -----------------------------------------------------------------------
+ // ctor provided to be used by derived classes
+ // -----------------------------------------------------------------------
+ FloatDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
-// -----------------------------------------------------------------------
-// Abstract interface from AbstractNumericFacetValidator
-// -----------------------------------------------------------------------
+ // -----------------------------------------------------------------------
+ // Abstract interface from AbstractNumericFacetValidator
+ // -----------------------------------------------------------------------
virtual void assignAdditionalFacet(const XMLCh* const key
, const XMLCh* const value);
diff --git a/src/xercesc/validators/datatype/HexBinaryDatatypeValidator.cpp b/src/xercesc/validators/datatype/HexBinaryDatatypeValidator.cpp
index c19ac5885c4728d24ed1622741c57a5e5497088f..509f71b46021293de2a7baf93f556ef070b42091 100644
--- a/src/xercesc/validators/datatype/HexBinaryDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/HexBinaryDatatypeValidator.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -117,8 +120,8 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-HexBinaryDatatypeValidator::HexBinaryDatatypeValidator()
-:AbstractStringValidator(0, 0, 0, DatatypeValidator::HexBinary)
+HexBinaryDatatypeValidator::HexBinaryDatatypeValidator(MemoryManager* const manager)
+:AbstractStringValidator(0, 0, 0, DatatypeValidator::HexBinary, manager)
{}
HexBinaryDatatypeValidator::~HexBinaryDatatypeValidator()
@@ -127,19 +130,23 @@ HexBinaryDatatypeValidator::~HexBinaryDatatypeValidator()
HexBinaryDatatypeValidator::HexBinaryDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::HexBinary)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::HexBinary, manager)
{
init(enums);
}
-DatatypeValidator* HexBinaryDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* HexBinaryDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new HexBinaryDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) HexBinaryDatatypeValidator(this, facets, enums, finalSet, manager);
}
// ---------------------------------------------------------------------------
diff --git a/src/xercesc/validators/datatype/HexBinaryDatatypeValidator.hpp b/src/xercesc/validators/datatype/HexBinaryDatatypeValidator.hpp
index 723145580a7b6337a4fa633d5e224e265e3ae48f..ebc9f34c39e3385faab7c3adf9ac35ce08e22e72 100644
--- a/src/xercesc/validators/datatype/HexBinaryDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/HexBinaryDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -88,15 +91,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- HexBinaryDatatypeValidator();
-
- HexBinaryDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ HexBinaryDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ HexBinaryDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~HexBinaryDatatypeValidator();
@@ -106,9 +115,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/IDDatatypeValidator.cpp b/src/xercesc/validators/datatype/IDDatatypeValidator.cpp
index 3298cec17110278bbc28a89ba512f149e57ead64..aab8261e129c817a0aea647660c2c9e8d1e98261 100644
--- a/src/xercesc/validators/datatype/IDDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/IDDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -99,17 +102,18 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-IDDatatypeValidator::IDDatatypeValidator()
-:StringDatatypeValidator(0, 0, 0, DatatypeValidator::ID)
+IDDatatypeValidator::IDDatatypeValidator(MemoryManager* const manager)
+:StringDatatypeValidator(0, 0, 0, DatatypeValidator::ID, manager)
,fIDRefList(0)
{}
IDDatatypeValidator::IDDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::ID)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::ID, manager)
,fIDRefList(0)
{
init(enums);
@@ -118,20 +122,24 @@ IDDatatypeValidator::IDDatatypeValidator(
IDDatatypeValidator::~IDDatatypeValidator()
{}
-DatatypeValidator* IDDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* IDDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new IDDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) IDDatatypeValidator(this, facets, enums, finalSet, manager);
}
IDDatatypeValidator::IDDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:StringDatatypeValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, type, manager)
,fIDRefList(0)
{
// do not invoke init() here!!!
@@ -164,7 +172,7 @@ void IDDatatypeValidator::addId(const XMLCh * const content)
}
else
{
- find = new XMLRefInfo(content);
+ find = new (fMemoryManager) XMLRefInfo(content);
fIDRefList->put((void*)find->getRefName(), find);
}
diff --git a/src/xercesc/validators/datatype/IDDatatypeValidator.hpp b/src/xercesc/validators/datatype/IDDatatypeValidator.hpp
index bfe12c91e26fb48280609cdc461cd74bb4c8176a..9c8fba25c3403fd82eedf8f8b3ec52015fcbc88a 100644
--- a/src/xercesc/validators/datatype/IDDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/IDDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -99,7 +102,6 @@
#define ID_DATATYPEVALIDATOR_HPP
#include <xercesc/validators/datatype/StringDatatypeValidator.hpp>
-#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/framework/XMLRefInfo.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -111,16 +113,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- IDDatatypeValidator();
-
- IDDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ IDDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ IDDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~IDDatatypeValidator();
//@}
@@ -145,9 +152,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
//@}
@@ -158,10 +169,14 @@ protected:
//
// ctor provided to be used by derived classes
//
- IDDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ IDDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual void checkValueSpace(const XMLCh* const content);
diff --git a/src/xercesc/validators/datatype/IDREFDatatypeValidator.cpp b/src/xercesc/validators/datatype/IDREFDatatypeValidator.cpp
index df8e7544aa6dc6567819773c885f967304c31360..bd457c5968c1e0dd4d227533551521073eaec66a 100644
--- a/src/xercesc/validators/datatype/IDREFDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/IDREFDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -97,17 +100,18 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-IDREFDatatypeValidator::IDREFDatatypeValidator()
-:StringDatatypeValidator(0, 0, 0, DatatypeValidator::IDREF)
+IDREFDatatypeValidator::IDREFDatatypeValidator(MemoryManager* const manager)
+:StringDatatypeValidator(0, 0, 0, DatatypeValidator::IDREF, manager)
,fIDRefList(0)
{}
IDREFDatatypeValidator::IDREFDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::IDREF)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::IDREF, manager)
,fIDRefList(0)
{
init(enums);
@@ -116,20 +120,24 @@ IDREFDatatypeValidator::IDREFDatatypeValidator(
IDREFDatatypeValidator::~IDREFDatatypeValidator()
{}
-DatatypeValidator* IDREFDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* IDREFDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new IDREFDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) IDREFDatatypeValidator(this, facets, enums, finalSet, manager);
}
IDREFDatatypeValidator::IDREFDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:StringDatatypeValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, type, manager)
,fIDRefList(0)
{
// do not invoke init() here!!!
@@ -158,7 +166,7 @@ void IDREFDatatypeValidator::addIdRef(const XMLCh* const content)
XMLRefInfo* find = fIDRefList->get(content);
if (!find)
{
- find = new XMLRefInfo(content);
+ find = new (fMemoryManager) XMLRefInfo(content);
fIDRefList->put((void*)find->getRefName(), find);
}
diff --git a/src/xercesc/validators/datatype/IDREFDatatypeValidator.hpp b/src/xercesc/validators/datatype/IDREFDatatypeValidator.hpp
index 8158cb2249ae7d49c6671ac6dbc9427e58933406..c015479287d104cddd2580a3418d62d445d3949b 100644
--- a/src/xercesc/validators/datatype/IDREFDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/IDREFDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -108,15 +111,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- IDREFDatatypeValidator();
-
- IDREFDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ IDREFDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ IDREFDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~IDREFDatatypeValidator();
@@ -144,9 +153,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
inline void setIDRefList(RefHashTableOf<XMLRefInfo>* fIDRefList);
@@ -155,10 +168,14 @@ protected:
//
// ctor provided to be used by derived classes
//
- IDREFDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ IDREFDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual void checkValueSpace(const XMLCh* const content);
diff --git a/src/xercesc/validators/datatype/ListDatatypeValidator.cpp b/src/xercesc/validators/datatype/ListDatatypeValidator.cpp
index 7626142abcd2f6f8614de4fc78c8d4f5ae9488c2..7fbef053ac3d7868c9d3b3d9343d3a5a6ac0d59a 100644
--- a/src/xercesc/validators/datatype/ListDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/ListDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.8 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.7 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -123,8 +126,8 @@ static XMLCh value2[BUF_LEN+1];
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-ListDatatypeValidator::ListDatatypeValidator()
-:AbstractStringValidator(0, 0, 0, DatatypeValidator::List)
+ListDatatypeValidator::ListDatatypeValidator(MemoryManager* const manager)
+:AbstractStringValidator(0, 0, 0, DatatypeValidator::List, manager)
,fContent(0)
{}
@@ -132,8 +135,9 @@ ListDatatypeValidator::ListDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::List)
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::List, manager)
,fContent(0)
{
//
@@ -152,12 +156,15 @@ ListDatatypeValidator::ListDatatypeValidator(
ListDatatypeValidator::~ListDatatypeValidator()
{}
-DatatypeValidator* ListDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* ListDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new ListDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) ListDatatypeValidator(this, facets, enums, finalSet, manager);
}
@@ -232,7 +239,7 @@ void ListDatatypeValidator::checkContent( BaseRefVectorOf<XMLCh>* tokenVector
if (getRegex() == 0)
{
try {
- setRegex(new RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
+ setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
}
catch (XMLException &e)
{
diff --git a/src/xercesc/validators/datatype/ListDatatypeValidator.hpp b/src/xercesc/validators/datatype/ListDatatypeValidator.hpp
index 9212ea3b563a78001b3f1bb8d87a7e08b341d3ad..cd94cd60a4e17e1120e30c6f17f66622b0997fd1 100644
--- a/src/xercesc/validators/datatype/ListDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/ListDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.6 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -122,16 +125,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- ListDatatypeValidator();
-
- ListDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ ListDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ ListDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~ListDatatypeValidator();
//@}
@@ -183,9 +191,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
DatatypeValidator* getItemTypeDTV() const;
diff --git a/src/xercesc/validators/datatype/MonthDatatypeValidator.cpp b/src/xercesc/validators/datatype/MonthDatatypeValidator.cpp
index 6bd54a415e6bef389ef9bc9eee275518815a45bc..cebfb2a0b160d9b9e8f1d0c3dace42806066930f 100644
--- a/src/xercesc/validators/datatype/MonthDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/MonthDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-MonthDatatypeValidator::MonthDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::Month)
+MonthDatatypeValidator::MonthDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::Month, manager)
{}
MonthDatatypeValidator::MonthDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Month)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Month, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ MonthDatatypeValidator::MonthDatatypeValidator(
MonthDatatypeValidator::~MonthDatatypeValidator()
{}
-DatatypeValidator* MonthDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* MonthDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new MonthDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) MonthDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* MonthDatatypeValidator::newInstance(
//
XMLDateTime* MonthDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/MonthDatatypeValidator.hpp b/src/xercesc/validators/datatype/MonthDatatypeValidator.hpp
index a70f25a55c33521e0d284cdf964c8c718bda61ed..8a1cc29aff9feb0a93a9efa086fbf93f121b3a0c 100644
--- a/src/xercesc/validators/datatype/MonthDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/MonthDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -85,28 +88,36 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- MonthDatatypeValidator();
-
- MonthDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ MonthDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ MonthDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~MonthDatatypeValidator();
-
//@}
/**
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/MonthDayDatatypeValidator.cpp b/src/xercesc/validators/datatype/MonthDayDatatypeValidator.cpp
index ba5ca7fc307ed6c54e80c45d04420e67e4d61b35..eaedba8996f4d8f26ce08b5c8226e36f67e4df00 100644
--- a/src/xercesc/validators/datatype/MonthDayDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/MonthDayDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-MonthDayDatatypeValidator::MonthDayDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::MonthDay)
+MonthDayDatatypeValidator::MonthDayDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::MonthDay, manager)
{}
MonthDayDatatypeValidator::MonthDayDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::MonthDay)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::MonthDay, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ MonthDayDatatypeValidator::MonthDayDatatypeValidator(
MonthDayDatatypeValidator::~MonthDayDatatypeValidator()
{}
-DatatypeValidator* MonthDayDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* MonthDayDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new MonthDayDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) MonthDayDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* MonthDayDatatypeValidator::newInstance(
//
XMLDateTime* MonthDayDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/MonthDayDatatypeValidator.hpp b/src/xercesc/validators/datatype/MonthDayDatatypeValidator.hpp
index 3dd63fce57aee030ee5c7243a4b5e3beaf4b8536..60cc9c06ced92bc7c11d16497254c5b05fa8361e 100644
--- a/src/xercesc/validators/datatype/MonthDayDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/MonthDayDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -85,28 +88,36 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- MonthDayDatatypeValidator();
-
- MonthDayDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ MonthDayDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ MonthDayDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~MonthDayDatatypeValidator();
-
//@}
/**
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/NCNameDatatypeValidator.cpp b/src/xercesc/validators/datatype/NCNameDatatypeValidator.cpp
index 80ab8b26d91a6ae0580ac7531aa5c60656c36583..7a8025915aaefedda960c7c9dbc3de28cbf7ab9a 100644
--- a/src/xercesc/validators/datatype/NCNameDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/NCNameDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.5 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -91,8 +94,8 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-NCNameDatatypeValidator::NCNameDatatypeValidator()
-:StringDatatypeValidator(0, 0, 0, DatatypeValidator::NCName)
+NCNameDatatypeValidator::NCNameDatatypeValidator(MemoryManager* const manager)
+:StringDatatypeValidator(0, 0, 0, DatatypeValidator::NCName, manager)
{}
NCNameDatatypeValidator::~NCNameDatatypeValidator()
@@ -101,27 +104,32 @@ NCNameDatatypeValidator::~NCNameDatatypeValidator()
NCNameDatatypeValidator::NCNameDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::NCName)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::NCName, manager)
{
init(enums);
}
-DatatypeValidator* NCNameDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* NCNameDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new NCNameDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) NCNameDatatypeValidator(this, facets, enums, finalSet, manager);
}
NCNameDatatypeValidator::NCNameDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:StringDatatypeValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, type, manager)
{
// do not invoke init() here!!!
}
diff --git a/src/xercesc/validators/datatype/NCNameDatatypeValidator.hpp b/src/xercesc/validators/datatype/NCNameDatatypeValidator.hpp
index d09902bbf94a0a7d68731cf517313929b6600fbe..2016c6c1eda66def607a4a859b4204551aaf2329 100644
--- a/src/xercesc/validators/datatype/NCNameDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/NCNameDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -91,15 +94,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- NCNameDatatypeValidator();
-
- NCNameDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ NCNameDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ NCNameDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~NCNameDatatypeValidator();
@@ -144,19 +153,27 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
//
// ctor provided to be used by derived classes
//
- NCNameDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ NCNameDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual void checkValueSpace(const XMLCh* const content);
diff --git a/src/xercesc/validators/datatype/NOTATIONDatatypeValidator.cpp b/src/xercesc/validators/datatype/NOTATIONDatatypeValidator.cpp
index 16215452d994cf22fe22cfe8de1253fc10c7fe8c..92a00e9d8b9270c7e44dc4b03de9c2c47ab602a7 100644
--- a/src/xercesc/validators/datatype/NOTATIONDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/NOTATIONDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -109,8 +112,8 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-NOTATIONDatatypeValidator::NOTATIONDatatypeValidator()
-:AbstractStringValidator(0, 0, 0, DatatypeValidator::NOTATION)
+NOTATIONDatatypeValidator::NOTATIONDatatypeValidator(MemoryManager* const manager)
+:AbstractStringValidator(0, 0, 0, DatatypeValidator::NOTATION, manager)
{}
NOTATIONDatatypeValidator::~NOTATIONDatatypeValidator()
@@ -120,18 +123,22 @@ NOTATIONDatatypeValidator::NOTATIONDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::NOTATION)
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::NOTATION, manager)
{
init(enums);
}
-DatatypeValidator* NOTATIONDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* NOTATIONDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new NOTATIONDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) NOTATIONDatatypeValidator(this, facets, enums, finalSet, manager);
}
// ---------------------------------------------------------------------------
diff --git a/src/xercesc/validators/datatype/NOTATIONDatatypeValidator.hpp b/src/xercesc/validators/datatype/NOTATIONDatatypeValidator.hpp
index cfd98ab744310fcc2b5c95edba8d039e6ab23a6b..174ae1317b03592432f02cbe098dd51c9807edfe 100644
--- a/src/xercesc/validators/datatype/NOTATIONDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/NOTATIONDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:26 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -99,15 +102,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- NOTATIONDatatypeValidator();
-
- NOTATIONDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ NOTATIONDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ NOTATIONDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~NOTATIONDatatypeValidator();
@@ -117,9 +126,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/NameDatatypeValidator.cpp b/src/xercesc/validators/datatype/NameDatatypeValidator.cpp
index 18f85b97db19bc0e2f9bead491908daac41c5f38..67ebc84906c75342bc3825443e13f6291663f0fb 100644
--- a/src/xercesc/validators/datatype/NameDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/NameDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.5 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -94,8 +97,8 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-NameDatatypeValidator::NameDatatypeValidator()
-:StringDatatypeValidator(0, 0, 0, DatatypeValidator::Name)
+NameDatatypeValidator::NameDatatypeValidator(MemoryManager* const manager)
+:StringDatatypeValidator(0, 0, 0, DatatypeValidator::Name, manager)
{}
NameDatatypeValidator::~NameDatatypeValidator()
@@ -104,27 +107,32 @@ NameDatatypeValidator::~NameDatatypeValidator()
NameDatatypeValidator::NameDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::Name)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::Name, manager)
{
init(enums);
}
-DatatypeValidator* NameDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* NameDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new NameDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) NameDatatypeValidator(this, facets, enums, finalSet, manager);
}
NameDatatypeValidator::NameDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:StringDatatypeValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:StringDatatypeValidator(baseValidator, facets, finalSet, type, manager)
{
// do not invoke init() here!!!
}
diff --git a/src/xercesc/validators/datatype/NameDatatypeValidator.hpp b/src/xercesc/validators/datatype/NameDatatypeValidator.hpp
index f98fb90b2839a2a7cf5e1e1ea5bbb60c048f54ae..9cb57ea39cb47c6e3e878ee2435965f3abe9fee8 100644
--- a/src/xercesc/validators/datatype/NameDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/NameDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -91,16 +94,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- NameDatatypeValidator();
-
- NameDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ NameDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ NameDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~NameDatatypeValidator();
//@}
@@ -144,19 +152,27 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
//
// ctor provided to be used by derived classes
//
- NameDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ NameDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual void checkValueSpace(const XMLCh* const content);
diff --git a/src/xercesc/validators/datatype/QNameDatatypeValidator.cpp b/src/xercesc/validators/datatype/QNameDatatypeValidator.cpp
index 604a6198683bfdecb7a7163f2fe9eb3c72f9a404..fd17e7f503b86030312eeed2c71ad4a8e6975dc7 100644
--- a/src/xercesc/validators/datatype/QNameDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/QNameDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -105,8 +108,8 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-QNameDatatypeValidator::QNameDatatypeValidator()
-:AbstractStringValidator(0, 0, 0, DatatypeValidator::QName)
+QNameDatatypeValidator::QNameDatatypeValidator(MemoryManager* const manager)
+:AbstractStringValidator(0, 0, 0, DatatypeValidator::QName, manager)
{}
QNameDatatypeValidator::~QNameDatatypeValidator()
@@ -115,19 +118,23 @@ QNameDatatypeValidator::~QNameDatatypeValidator()
QNameDatatypeValidator::QNameDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::QName)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::QName, manager)
{
init(enums);
}
-DatatypeValidator* QNameDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* QNameDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new QNameDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) QNameDatatypeValidator(this, facets, enums, finalSet, manager);
}
// ---------------------------------------------------------------------------
diff --git a/src/xercesc/validators/datatype/QNameDatatypeValidator.hpp b/src/xercesc/validators/datatype/QNameDatatypeValidator.hpp
index a3999606d59cc697307e273b6dc4a76ebe9131d9..98328468301a87911f88a5f87fd11e3eb8962439 100644
--- a/src/xercesc/validators/datatype/QNameDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/QNameDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -99,16 +102,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- QNameDatatypeValidator();
-
- QNameDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ QNameDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ QNameDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~QNameDatatypeValidator();
//@}
@@ -117,9 +125,14 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+
protected:
virtual void assignAdditionalFacet(const XMLCh* const key
diff --git a/src/xercesc/validators/datatype/StringDatatypeValidator.cpp b/src/xercesc/validators/datatype/StringDatatypeValidator.cpp
index 202fac8896a9ac82934c3edc11c2359affce0967..83cbb97eb563ee576e4e81be24d0824f6c72b534 100644
--- a/src/xercesc/validators/datatype/StringDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/StringDatatypeValidator.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -136,17 +139,18 @@ static XMLCh value2[BUF_LEN+1];
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-StringDatatypeValidator::StringDatatypeValidator()
-:AbstractStringValidator(0, 0, 0, DatatypeValidator::String)
+StringDatatypeValidator::StringDatatypeValidator(MemoryManager* const manager)
+:AbstractStringValidator(0, 0, 0, DatatypeValidator::String, manager)
,fWhiteSpace(DatatypeValidator::PRESERVE)
{}
StringDatatypeValidator::StringDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::String)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:AbstractStringValidator(baseValidator, facets, finalSet, DatatypeValidator::String, manager)
,fWhiteSpace(DatatypeValidator::PRESERVE)
{
init(enums);
@@ -155,20 +159,24 @@ StringDatatypeValidator::StringDatatypeValidator(
StringDatatypeValidator::~StringDatatypeValidator()
{}
-DatatypeValidator* StringDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* StringDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new StringDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) StringDatatypeValidator(this, facets, enums, finalSet, manager);
}
StringDatatypeValidator::StringDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
, const int finalSet
- , const ValidatorType type)
-:AbstractStringValidator(baseValidator, facets, finalSet, type)
+ , const ValidatorType type
+ , MemoryManager* const manager)
+:AbstractStringValidator(baseValidator, facets, finalSet, type, manager)
,fWhiteSpace(DatatypeValidator::PRESERVE)
{
// do not invoke init() here!!!
diff --git a/src/xercesc/validators/datatype/StringDatatypeValidator.hpp b/src/xercesc/validators/datatype/StringDatatypeValidator.hpp
index 8f5f22e7e75ef775bc68a9954901964990b6f854..b4b41bcba183026534ad7fbf73f35843ecf1abe8 100644
--- a/src/xercesc/validators/datatype/StringDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/StringDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -97,16 +100,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- StringDatatypeValidator();
-
- StringDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ StringDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ StringDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~StringDatatypeValidator();
//@}
@@ -125,19 +133,27 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
//
// ctor provided to be used by derived classes
//
- StringDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , const int finalSet
- , const ValidatorType type);
+ StringDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , const int finalSet
+ , const ValidatorType type
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual void assignAdditionalFacet(const XMLCh* const key
, const XMLCh* const value);
diff --git a/src/xercesc/validators/datatype/TimeDatatypeValidator.cpp b/src/xercesc/validators/datatype/TimeDatatypeValidator.cpp
index 24eb435d661182edb59c70baff10a24ec6b38efc..12df015f8ac39483d984c1092b6c1a9166c029be 100644
--- a/src/xercesc/validators/datatype/TimeDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/TimeDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-TimeDatatypeValidator::TimeDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::Time)
+TimeDatatypeValidator::TimeDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::Time, manager)
{}
TimeDatatypeValidator::TimeDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Time)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Time, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ TimeDatatypeValidator::TimeDatatypeValidator(
TimeDatatypeValidator::~TimeDatatypeValidator()
{}
-DatatypeValidator* TimeDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* TimeDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new TimeDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) TimeDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* TimeDatatypeValidator::newInstance(
//
XMLDateTime* TimeDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/TimeDatatypeValidator.hpp b/src/xercesc/validators/datatype/TimeDatatypeValidator.hpp
index fed032697038d9ba02e6f6588716262ab78825ca..1423019e2912be1f315b235b8f76a29d9efd132b 100644
--- a/src/xercesc/validators/datatype/TimeDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/TimeDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -86,16 +89,21 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- TimeDatatypeValidator();
-
- TimeDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ TimeDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ TimeDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~TimeDatatypeValidator();
@@ -105,9 +113,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/UnionDatatypeValidator.cpp b/src/xercesc/validators/datatype/UnionDatatypeValidator.cpp
index aab7c162f89c0220f6b6b729e6ebb70d9a13dbf2..b240388a191b421a8222b9adcebb731f6b2b2b77 100644
--- a/src/xercesc/validators/datatype/UnionDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/UnionDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.9 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.8 2003/02/06 13:51:55 gareth
* fixed bug with multiple attributes being validated by the same union type.
*
@@ -115,8 +118,8 @@ static XMLCh value2[BUF_LEN+1];
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-UnionDatatypeValidator::UnionDatatypeValidator()
-:DatatypeValidator(0, 0, 0, DatatypeValidator::Union)
+UnionDatatypeValidator::UnionDatatypeValidator(MemoryManager* const manager)
+:DatatypeValidator(0, 0, 0, DatatypeValidator::Union, manager)
,fEnumerationInherited(false)
,fEnumeration(0)
,fMemberTypeValidators(0)
@@ -130,8 +133,9 @@ UnionDatatypeValidator::~UnionDatatypeValidator()
UnionDatatypeValidator::UnionDatatypeValidator(
RefVectorOf<DatatypeValidator>* const memberTypeValidators
- , const int finalSet)
-:DatatypeValidator(0, 0, finalSet, DatatypeValidator::Union)
+ , const int finalSet
+ , MemoryManager* const manager)
+:DatatypeValidator(0, 0, finalSet, DatatypeValidator::Union, manager)
,fEnumerationInherited(false)
,fEnumeration(0)
,fMemberTypeValidators(0)
@@ -150,9 +154,10 @@ UnionDatatypeValidator::UnionDatatypeValidator(
UnionDatatypeValidator::UnionDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::Union)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DatatypeValidator(baseValidator, facets, finalSet, DatatypeValidator::Union, manager)
,fEnumerationInherited(false)
,fEnumeration(0)
,fMemberTypeValidators(0)
@@ -339,7 +344,7 @@ void UnionDatatypeValidator::checkContent(const XMLCh* const content, bool asBas
if (getRegex() == 0)
{
try {
- setRegex(new RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
+ setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption));
}
catch (XMLException &e)
{
diff --git a/src/xercesc/validators/datatype/UnionDatatypeValidator.hpp b/src/xercesc/validators/datatype/UnionDatatypeValidator.hpp
index 27154a110b42cf4b99443974bf2f379dc260902e..6a09dc92edccd629d91150e9e50a873765ef3162 100644
--- a/src/xercesc/validators/datatype/UnionDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/UnionDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.9 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.8 2003/02/06 13:51:55 gareth
* fixed bug with multiple attributes being validated by the same union type.
*
@@ -112,7 +115,6 @@
#define UNION_DATATYPEVALIDATOR_HPP
#include <xercesc/validators/datatype/DatatypeValidator.hpp>
-#include <xercesc/validators/schema/SchemaSymbols.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -123,10 +125,13 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor. */
//@{
- UnionDatatypeValidator();
+ UnionDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
//
// constructor for native Union datatype validator
@@ -134,8 +139,12 @@ public:
// <union memberTypes="member1 member2 ...">
// </simpleType>
//
- UnionDatatypeValidator(RefVectorOf<DatatypeValidator>* const memberTypeValidators
- , const int finalSet);
+ UnionDatatypeValidator
+ (
+ RefVectorOf<DatatypeValidator>* const memberTypeValidators
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
//
// constructor for derived Union datatype validator
@@ -146,10 +155,14 @@ public:
// </restriction>
// </simpleType>
//
- UnionDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ UnionDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
virtual ~UnionDatatypeValidator();
@@ -219,9 +232,13 @@ public:
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
RefVectorOf<DatatypeValidator>* getMemberTypeValidators() const;
@@ -291,12 +308,15 @@ private:
DatatypeValidator* fValidatedDatatype;
};
-inline DatatypeValidator* UnionDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+inline DatatypeValidator* UnionDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new UnionDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) UnionDatatypeValidator(this, facets, enums, finalSet, manager);
}
inline void UnionDatatypeValidator::validate( const XMLCh* const content)
diff --git a/src/xercesc/validators/datatype/YearDatatypeValidator.cpp b/src/xercesc/validators/datatype/YearDatatypeValidator.cpp
index 92e589b9bda725e6d723a8aca64c070eadf14cf8..180f5227afb2d713096cd286453cd77448f854b7 100644
--- a/src/xercesc/validators/datatype/YearDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/YearDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-YearDatatypeValidator::YearDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::Year)
+YearDatatypeValidator::YearDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::Year, manager)
{}
YearDatatypeValidator::YearDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Year)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::Year, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ YearDatatypeValidator::YearDatatypeValidator(
YearDatatypeValidator::~YearDatatypeValidator()
{}
-DatatypeValidator* YearDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* YearDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new YearDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) YearDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* YearDatatypeValidator::newInstance(
//
XMLDateTime* YearDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/YearDatatypeValidator.hpp b/src/xercesc/validators/datatype/YearDatatypeValidator.hpp
index 5d94c08082bf5c794961ebc9d4a0a6d5ee8e24b4..e08c6f4358f938775e1f4829b8be431cb5dab59c 100644
--- a/src/xercesc/validators/datatype/YearDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/YearDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -85,28 +88,36 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- YearDatatypeValidator();
-
- YearDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ YearDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ YearDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~YearDatatypeValidator();
-
//@}
/**
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/datatype/YearMonthDatatypeValidator.cpp b/src/xercesc/validators/datatype/YearMonthDatatypeValidator.cpp
index 90a3fb271a67f393df3e36390a1eb3e91f8139cb..474821c1b41d8c8b87aa151e3c07c9283a033d23 100644
--- a/src/xercesc/validators/datatype/YearMonthDatatypeValidator.cpp
+++ b/src/xercesc/validators/datatype/YearMonthDatatypeValidator.cpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -87,16 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// Constructors and Destructor
// ---------------------------------------------------------------------------
-YearMonthDatatypeValidator::YearMonthDatatypeValidator()
-:DateTimeValidator(0, 0, 0, DatatypeValidator::YearMonth)
+YearMonthDatatypeValidator::YearMonthDatatypeValidator(MemoryManager* const manager)
+:DateTimeValidator(0, 0, 0, DatatypeValidator::YearMonth, manager)
{}
YearMonthDatatypeValidator::YearMonthDatatypeValidator(
DatatypeValidator* const baseValidator
, RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
-:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::YearMonth)
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager)
+:DateTimeValidator(baseValidator, facets, finalSet, DatatypeValidator::YearMonth, manager)
{
init(enums);
}
@@ -104,12 +108,15 @@ YearMonthDatatypeValidator::YearMonthDatatypeValidator(
YearMonthDatatypeValidator::~YearMonthDatatypeValidator()
{}
-DatatypeValidator* YearMonthDatatypeValidator::newInstance(
- RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet)
+DatatypeValidator* YearMonthDatatypeValidator::newInstance
+(
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager
+)
{
- return (DatatypeValidator*) new YearMonthDatatypeValidator(this, facets, enums, finalSet);
+ return (DatatypeValidator*) new (manager) YearMonthDatatypeValidator(this, facets, enums, finalSet, manager);
}
//
@@ -117,7 +124,7 @@ DatatypeValidator* YearMonthDatatypeValidator::newInstance(
//
XMLDateTime* YearMonthDatatypeValidator::parse(const XMLCh* const content)
{
- XMLDateTime *pRetDate = new XMLDateTime(content);
+ XMLDateTime *pRetDate = new (fMemoryManager) XMLDateTime(content);
try
{
diff --git a/src/xercesc/validators/datatype/YearMonthDatatypeValidator.hpp b/src/xercesc/validators/datatype/YearMonthDatatypeValidator.hpp
index 39e0939bb1a5b9b9fb9fc4ce37b4e179b158686c..81d9d8544699e26a8de08b4117517fd90bd69a84 100644
--- a/src/xercesc/validators/datatype/YearMonthDatatypeValidator.hpp
+++ b/src/xercesc/validators/datatype/YearMonthDatatypeValidator.hpp
@@ -57,6 +57,9 @@
/*
* $Id$
* $Log$
+ * Revision 1.4 2003/05/15 18:53:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:55 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -85,28 +88,36 @@ public:
// -----------------------------------------------------------------------
// Public ctor/dtor
// -----------------------------------------------------------------------
- /** @name Constructor. */
+ /** @name Constructors and Destructor */
//@{
- YearMonthDatatypeValidator();
-
- YearMonthDatatypeValidator(DatatypeValidator* const baseValidator
- , RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
-
+ YearMonthDatatypeValidator
+ (
+ MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ YearMonthDatatypeValidator
+ (
+ DatatypeValidator* const baseValidator
+ , RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
~YearMonthDatatypeValidator();
-
//@}
/**
* Returns an instance of the base datatype validator class
* Used by the DatatypeValidatorFactory.
*/
- virtual DatatypeValidator* newInstance(RefHashTableOf<KVStringPair>* const facets
- , RefArrayVectorOf<XMLCh>* const enums
- , const int finalSet);
+ virtual DatatypeValidator* newInstance
+ (
+ RefHashTableOf<KVStringPair>* const facets
+ , RefArrayVectorOf<XMLCh>* const enums
+ , const int finalSet
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
protected:
diff --git a/src/xercesc/validators/schema/ComplexTypeInfo.cpp b/src/xercesc/validators/schema/ComplexTypeInfo.cpp
index 680b74ebd94a14f45722a185456275092b2b5cfb..b105c67b6759c254efeec15164a98d17e903ffe3 100644
--- a/src/xercesc/validators/schema/ComplexTypeInfo.cpp
+++ b/src/xercesc/validators/schema/ComplexTypeInfo.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.6 2003/01/29 19:57:30 gareth
* API to retrive local and uri part of the type name
*
@@ -176,8 +179,9 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// ComplexTypeInfo: Constructors and Destructor
// ---------------------------------------------------------------------------
-ComplexTypeInfo::ComplexTypeInfo()
- : fAbstract(false)
+ComplexTypeInfo::ComplexTypeInfo(MemoryManager* const manager)
+ : fAnonymous(false)
+ , fAbstract(false)
, fAdoptContentSpec(true)
, fAttWithTypeId(false)
, fPreprocessed(false)
@@ -205,7 +209,7 @@ ComplexTypeInfo::ComplexTypeInfo()
, fContentSpecOrgURISize(16)
, fSpecNodesToDelete(0)
, fLocator(0)
- , fAnonymous(false)
+ , fMemoryManager(manager)
{
}
@@ -213,9 +217,9 @@ ComplexTypeInfo::ComplexTypeInfo()
ComplexTypeInfo::~ComplexTypeInfo()
{
- delete [] fTypeName;
- delete [] fTypeLocalName;
- delete [] fTypeUri;
+ fMemoryManager->deallocate(fTypeName); //delete [] fTypeName;
+ fMemoryManager->deallocate(fTypeLocalName); //delete [] fTypeLocalName;
+ fMemoryManager->deallocate(fTypeUri); //delete [] fTypeUri;
if (fAdoptContentSpec) {
delete fContentSpec;
@@ -229,8 +233,8 @@ ComplexTypeInfo::~ComplexTypeInfo()
delete fLocator;
delete fContentModel;
- delete [] fFormattedModel;
- delete [] fContentSpecOrgURI;
+ fMemoryManager->deallocate(fFormattedModel); //delete [] fFormattedModel;
+ fMemoryManager->deallocate(fContentSpecOrgURI); //delete [] fContentSpecOrgURI;
}
// ---------------------------------------------------------------------------
@@ -326,7 +330,7 @@ XMLAttDef* ComplexTypeInfo::findAttr(const XMLCh* const qName
faultInAttDefList();
// And add a default attribute for this name
- retVal = new SchemaAttDef(prefix, baseName, uriId);
+ retVal = new (fMemoryManager) SchemaAttDef(prefix, baseName, uriId);
retVal->setElemId(getElementId());
fAttDefs->put((void*)retVal->getAttName()->getLocalPart(), uriId, retVal);
@@ -364,7 +368,7 @@ void ComplexTypeInfo::checkUniqueParticleAttribution (SchemaGrammar* const pG
XMLValidator* const pValidator)
{
if (fContentSpec) {
- ContentSpecNode* specNode = new ContentSpecNode(*fContentSpec);
+ ContentSpecNode* specNode = new (fMemoryManager) ContentSpecNode(*fContentSpec);
XMLContentModel* cm = makeContentModel(true, specNode);
if (cm) {
@@ -383,7 +387,7 @@ void ComplexTypeInfo::faultInAttDefList() const
{
// Use a hash modulus of 29 and tell it owns its elements
((ComplexTypeInfo*)this)->fAttDefs =
- new RefHash2KeysTableOf<SchemaAttDef>(29, true);
+ new (fMemoryManager) RefHash2KeysTableOf<SchemaAttDef>(29, true);
}
XMLCh* ComplexTypeInfo::formatContentModel() const
@@ -391,13 +395,13 @@ XMLCh* ComplexTypeInfo::formatContentModel() const
XMLCh* newValue = 0;
if (fContentType == SchemaElementDecl::Any)
{
- newValue = XMLString::replicate(XMLUni::fgAnyString);
+ newValue = XMLString::replicate(XMLUni::fgAnyString, fMemoryManager);
}
- else if (fContentType == SchemaElementDecl::Empty)
+ else if (fContentType == SchemaElementDecl::Empty)
{
- newValue = XMLString::replicate(XMLUni::fgEmptyString);
+ newValue = XMLString::replicate(XMLUni::fgEmptyString, fMemoryManager);
}
- else
+ else
{
//
// Use a temp XML buffer to format into. Content models could be
@@ -409,9 +413,12 @@ XMLCh* ComplexTypeInfo::formatContentModel() const
if (specNode) {
XMLBuffer bufFmt;
-
specNode->formatSpec(bufFmt);
- newValue = XMLString::replicate(bufFmt.getRawBuffer());
+ newValue = XMLString::replicate
+ (
+ bufFmt.getRawBuffer()
+ , fMemoryManager
+ );
}
}
return newValue;
@@ -420,14 +427,17 @@ XMLCh* ComplexTypeInfo::formatContentModel() const
XMLContentModel* ComplexTypeInfo::makeContentModel(const bool checkUPA, ContentSpecNode* const specNode)
{
if ((specNode || fContentSpec) && !fSpecNodesToDelete) {
- fSpecNodesToDelete = new RefVectorOf<ContentSpecNode>(8);
+ fSpecNodesToDelete = new (fMemoryManager) RefVectorOf<ContentSpecNode>(8);
}
// expand the content spec first
ContentSpecNode* aSpecNode = specNode;
if (aSpecNode) {
- fContentSpecOrgURI = new unsigned int[fContentSpecOrgURISize];
+ fContentSpecOrgURI = (unsigned int*) fMemoryManager->allocate
+ (
+ fContentSpecOrgURISize * sizeof(unsigned int)
+ ); //new unsigned int[fContentSpecOrgURISize];
aSpecNode = convertContentSpecTree(aSpecNode, checkUPA);
fSpecNodesToDelete->addElement(aSpecNode);
}
@@ -454,7 +464,7 @@ XMLContentModel* ComplexTypeInfo::makeContentModel(const bool checkUPA, ContentS
// Just create a mixel content model object. This type of
// content model is optimized for mixed content validation.
//
- cmRet = new MixedContentModel(false, aSpecNode);
+ cmRet = new (fMemoryManager) MixedContentModel(false, aSpecNode);
}
else if (fContentType == SchemaElementDecl::Mixed_Complex) {
@@ -514,12 +524,12 @@ XMLContentModel* ComplexTypeInfo::createChildModel(ContentSpecNode* specNode, co
// All the nodes under an ALL must be additional ALL nodes and
// ELEMENTs (or ELEMENTs under ZERO_OR_ONE nodes.)
// We collapse the ELEMENTs into a single vector.
- return new AllContentModel(specNode, true);
+ return new (fMemoryManager) AllContentModel(specNode, true, fMemoryManager);
}
else if (specType == ContentSpecNode::ZeroOrOne) {
// An ALL node can appear under a ZERO_OR_ONE node.
if (specNode->getFirst()->getType() == ContentSpecNode::All) {
- return new AllContentModel(specNode->getFirst(), true);
+ return new (fMemoryManager) AllContentModel(specNode->getFirst(), true, fMemoryManager);
}
}
@@ -528,7 +538,7 @@ XMLContentModel* ComplexTypeInfo::createChildModel(ContentSpecNode* specNode, co
else if (specType == ContentSpecNode::Leaf)
{
// Create a simple content model
- return new SimpleContentModel
+ return new (fMemoryManager) SimpleContentModel
(
false
, specNode->getElement()
@@ -547,7 +557,7 @@ XMLContentModel* ComplexTypeInfo::createChildModel(ContentSpecNode* specNode, co
&& (specNode->getSecond())
&& (specNode->getSecond()->getType() == ContentSpecNode::Leaf))
{
- return new SimpleContentModel
+ return new (fMemoryManager) SimpleContentModel
(
false
, specNode->getFirst()->getElement()
@@ -567,7 +577,7 @@ XMLContentModel* ComplexTypeInfo::createChildModel(ContentSpecNode* specNode, co
//
if (specNode->getFirst()->getType() == ContentSpecNode::Leaf)
{
- return new SimpleContentModel
+ return new (fMemoryManager) SimpleContentModel
(
false
, specNode->getFirst()->getElement()
@@ -576,11 +586,11 @@ XMLContentModel* ComplexTypeInfo::createChildModel(ContentSpecNode* specNode, co
);
}
else if (specNode->getFirst()->getType() == ContentSpecNode::All)
- return new AllContentModel(specNode->getFirst(), false);
+ return new (fMemoryManager) AllContentModel(specNode->getFirst(), false, fMemoryManager);
}
else if (specType == ContentSpecNode::All)
- return new AllContentModel(specNode, false);
+ return new (fMemoryManager) AllContentModel(specNode, false, fMemoryManager);
else
{
@@ -588,7 +598,7 @@ XMLContentModel* ComplexTypeInfo::createChildModel(ContentSpecNode* specNode, co
}
// Its not any simple type of content, so create a DFA based content model
- return new DFAContentModel(false, specNode, isMixed);
+ return new (fMemoryManager) DFAContentModel(false, specNode, isMixed, fMemoryManager);
}
ContentSpecNode*
@@ -677,20 +687,20 @@ ContentSpecNode* ComplexTypeInfo::expandContentModel(ContentSpecNode* const spec
}
else if (minOccurs == 0 && maxOccurs == 1) {
- retNode = new ContentSpecNode(ContentSpecNode::ZeroOrOne, retNode, 0);
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::ZeroOrOne, retNode, 0);
}
else if (minOccurs == 0 && maxOccurs == -1) {
- retNode = new ContentSpecNode(ContentSpecNode::ZeroOrMore, retNode, 0);
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::ZeroOrMore, retNode, 0);
}
else if (minOccurs == 1 && maxOccurs == -1) {
- retNode = new ContentSpecNode(ContentSpecNode::OneOrMore, retNode, 0);
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::OneOrMore, retNode, 0);
}
else if (maxOccurs == -1) {
- retNode = new ContentSpecNode(ContentSpecNode::OneOrMore, retNode, 0);
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::OneOrMore, retNode, 0);
for (int i=0; i < (int)(minOccurs-1); i++) {
- retNode = new ContentSpecNode(ContentSpecNode::Sequence,
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::Sequence,
saveNode, retNode, false);
}
}
@@ -699,12 +709,12 @@ ContentSpecNode* ComplexTypeInfo::expandContentModel(ContentSpecNode* const spec
if (minOccurs == 0) {
ContentSpecNode* optional =
- new ContentSpecNode(ContentSpecNode::ZeroOrOne, saveNode, 0);
+ new (fMemoryManager) ContentSpecNode(ContentSpecNode::ZeroOrOne, saveNode, 0);
retNode = optional;
for (int i=0; i < (int)(maxOccurs-minOccurs-1); i++) {
- retNode = new ContentSpecNode(ContentSpecNode::Sequence,
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::Sequence,
retNode, optional, true, false);
}
}
@@ -712,11 +722,11 @@ ContentSpecNode* ComplexTypeInfo::expandContentModel(ContentSpecNode* const spec
if (minOccurs > 1) {
- retNode = new ContentSpecNode(ContentSpecNode::Sequence,
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::Sequence,
retNode, saveNode, true, false);
for (int i=1; i < (int)(minOccurs-1); i++) {
- retNode = new ContentSpecNode(ContentSpecNode::Sequence,
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::Sequence,
retNode, saveNode, true, false);
}
}
@@ -725,13 +735,13 @@ ContentSpecNode* ComplexTypeInfo::expandContentModel(ContentSpecNode* const spec
if (counter > 0) {
- ContentSpecNode* optional = new ContentSpecNode(ContentSpecNode::ZeroOrOne, saveNode, 0, false);
+ ContentSpecNode* optional = new (fMemoryManager) ContentSpecNode(ContentSpecNode::ZeroOrOne, saveNode, 0, false);
- retNode = new ContentSpecNode(ContentSpecNode::Sequence, retNode, optional);
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::Sequence, retNode, optional);
for (int j=1; j < counter; j++) {
- retNode = new ContentSpecNode(ContentSpecNode::Sequence,
+ retNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::Sequence,
retNode, optional, true, false);
}
}
@@ -744,7 +754,10 @@ ContentSpecNode* ComplexTypeInfo::expandContentModel(ContentSpecNode* const spec
void ComplexTypeInfo::resizeContentSpecOrgURI() {
unsigned int newSize = fContentSpecOrgURISize * 2;
- unsigned int* newContentSpecOrgURI = new unsigned int[newSize];
+ unsigned int* newContentSpecOrgURI = (unsigned int*) fMemoryManager->allocate
+ (
+ newSize * sizeof(unsigned int)
+ ); //new unsigned int[newSize];
// Copy the existing values
unsigned int index = 0;
@@ -755,7 +768,7 @@ void ComplexTypeInfo::resizeContentSpecOrgURI() {
newContentSpecOrgURI[index] = 0;
// Delete the old array and udpate our members
- delete [] fContentSpecOrgURI;
+ fMemoryManager->deallocate(fContentSpecOrgURI); //delete [] fContentSpecOrgURI;
fContentSpecOrgURI = newContentSpecOrgURI;
fContentSpecOrgURISize = newSize;
}
diff --git a/src/xercesc/validators/schema/ComplexTypeInfo.hpp b/src/xercesc/validators/schema/ComplexTypeInfo.hpp
index 884b6b9f3b76b7c659dafd97dc236cab262385c2..9490922c4938b4c92e4f7fd1f50810046b42fe66 100644
--- a/src/xercesc/validators/schema/ComplexTypeInfo.hpp
+++ b/src/xercesc/validators/schema/ComplexTypeInfo.hpp
@@ -74,7 +74,6 @@
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/RefHash2KeysTableOf.hpp>
#include <xercesc/util/RefVectorOf.hpp>
-#include <xercesc/util/Janitor.hpp>
#include <xercesc/framework/XMLElementDecl.hpp>
#include <xercesc/framework/XMLContentModel.hpp>
#include <xercesc/validators/schema/SchemaAttDef.hpp>
@@ -92,13 +91,13 @@ class SchemaElementDecl;
class XSDLocator;
-class VALIDATORS_EXPORT ComplexTypeInfo
+class VALIDATORS_EXPORT ComplexTypeInfo : public XMemory
{
public:
// -----------------------------------------------------------------------
// Public Constructors/Destructor
// -----------------------------------------------------------------------
- ComplexTypeInfo();
+ ComplexTypeInfo(MemoryManager* const manager);
~ComplexTypeInfo();
// -----------------------------------------------------------------------
@@ -213,6 +212,7 @@ private:
// -----------------------------------------------------------------------
// Private data members
// -----------------------------------------------------------------------
+ bool fAnonymous;
bool fAbstract;
bool fAdoptContentSpec;
bool fAttWithTypeId;
@@ -241,7 +241,7 @@ private:
unsigned int fUniqueURI;
unsigned int fContentSpecOrgURISize;
XSDLocator* fLocator;
- bool fAnonymous;
+ MemoryManager* fMemoryManager;
};
// ---------------------------------------------------------------------------
@@ -402,7 +402,10 @@ inline const XMLCh* ComplexTypeInfo::getTypeLocalName() const
if(!fTypeLocalName) {
int index = XMLString::indexOf(fTypeName, chComma);
int length = XMLString::stringLen(fTypeName);
- XMLCh *tName = new XMLCh[length - index + 1];
+ XMLCh *tName = (XMLCh*) fMemoryManager->allocate
+ (
+ (length - index + 1) * sizeof(XMLCh)
+ ); //new XMLCh[length - index + 1];
XMLString::subString(tName, fTypeName, index + 1, length);
((ComplexTypeInfo *)this)->fTypeLocalName = tName;
}
@@ -414,7 +417,10 @@ inline const XMLCh* ComplexTypeInfo::getTypeUri() const
{
if(!fTypeUri) {
int index = XMLString::indexOf(fTypeName, chComma);
- XMLCh *uri = new XMLCh[index + 1];
+ XMLCh *uri = (XMLCh*) fMemoryManager->allocate
+ (
+ (index + 1) * sizeof(XMLCh)
+ ); //new XMLCh[index + 1];
XMLString::subString(uri, fTypeName, 0, index);
((ComplexTypeInfo *)this)->fTypeUri = uri;
}
@@ -478,13 +484,12 @@ ComplexTypeInfo::setContentType(const int contentType) {
inline void ComplexTypeInfo::setTypeName(const XMLCh* const typeName) {
- delete [] fTypeName;
- delete [] fTypeLocalName;
- fTypeLocalName = 0;
- delete [] fTypeUri;
- fTypeUri = 0;
+ fMemoryManager->deallocate(fTypeName);//delete [] fTypeName;
+ fMemoryManager->deallocate(fTypeLocalName);//delete [] fTypeLocalName;
+ fMemoryManager->deallocate(fTypeUri);//delete [] fTypeUri;
+ fTypeLocalName = fTypeUri = 0;
- fTypeName = XMLString::replicate(typeName);
+ fTypeName = XMLString::replicate(typeName, fMemoryManager);
}
inline void
@@ -508,7 +513,7 @@ ComplexTypeInfo::setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo) {
inline void ComplexTypeInfo::addElement(SchemaElementDecl* const elem) {
if (!fElements) {
- fElements = new RefVectorOf<SchemaElementDecl>(8, false);
+ fElements = new (fMemoryManager) RefVectorOf<SchemaElementDecl>(8, false);
}
else if (fElements->containsElement(elem)) {
return;
diff --git a/src/xercesc/validators/schema/GeneralAttributeCheck.cpp b/src/xercesc/validators/schema/GeneralAttributeCheck.cpp
index c095bc4e5892652fa55a54ab843d3a360ac1c618..767bd2fd7dbf44d69083ad686bb57f4c62ecbfb1 100644
--- a/src/xercesc/validators/schema/GeneralAttributeCheck.cpp
+++ b/src/xercesc/validators/schema/GeneralAttributeCheck.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.13 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.12 2003/01/17 15:35:57 knoaman
* Fix for attribute checking of schema declarations.
*
@@ -211,8 +214,10 @@ static XMLRegisterCleanup GeneralAttCheckCleanup;
// ---------------------------------------------------------------------------
// GeneralAttributeCheck: Constructors and Destructor
// ---------------------------------------------------------------------------
-GeneralAttributeCheck::GeneralAttributeCheck()
- : fIDRefList(0)
+GeneralAttributeCheck::GeneralAttributeCheck(MemoryManager* const manager)
+ : fMemoryManager(manager)
+ , fIDRefList(0)
+ , fIDValidator(manager)
{
mapElements();
}
@@ -227,7 +232,7 @@ GeneralAttributeCheck::~GeneralAttributeCheck()
// ---------------------------------------------------------------------------
void GeneralAttributeCheck::setUpValidators() {
- DatatypeValidatorFactory dvFactory;
+ DatatypeValidatorFactory dvFactory(fMemoryManager);
dvFactory.expandRegistryToFullSchemaSet();
fNonNegIntDV = dvFactory.getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER);
diff --git a/src/xercesc/validators/schema/GeneralAttributeCheck.hpp b/src/xercesc/validators/schema/GeneralAttributeCheck.hpp
index 9401b334a1244a4ae75f030f91b96289c52fa7ed..95f8fcc2243ee9846cc4952bb693eca25d7d8213 100644
--- a/src/xercesc/validators/schema/GeneralAttributeCheck.hpp
+++ b/src/xercesc/validators/schema/GeneralAttributeCheck.hpp
@@ -69,11 +69,9 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/RefVectorOf.hpp>
#include <xercesc/util/RefHashTableOf.hpp>
-#include <xercesc/util/RefHash2KeysTableOf.hpp>
-#include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
#include <xercesc/util/ValueHashTableOf.hpp>
+#include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -84,7 +82,7 @@ class TraverseSchema;
class DOMElement;
-class VALIDATORS_EXPORT GeneralAttributeCheck
+class VALIDATORS_EXPORT GeneralAttributeCheck : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -219,7 +217,7 @@ public:
// -----------------------------------------------------------------------
// Constructor/Destructor
// -----------------------------------------------------------------------
- GeneralAttributeCheck();
+ GeneralAttributeCheck(MemoryManager* const manager);
~GeneralAttributeCheck();
// -----------------------------------------------------------------------
@@ -285,8 +283,9 @@ private:
static DatatypeValidator* fAnyURIDV;
static unsigned short fgElemAttTable[E_Count][A_Count];
static const XMLCh* fAttNames[A_Count];
- IDDatatypeValidator fIDValidator;
+ MemoryManager* fMemoryManager;
RefHashTableOf<XMLRefInfo>* fIDRefList;
+ IDDatatypeValidator fIDValidator;
};
diff --git a/src/xercesc/validators/schema/NamespaceScope.cpp b/src/xercesc/validators/schema/NamespaceScope.cpp
index ce9f7f67eab1f67aeba393863de8d72ccb9e8784..7c5ce40ae57883cef0305b1821cc6e074b22362c 100644
--- a/src/xercesc/validators/schema/NamespaceScope.cpp
+++ b/src/xercesc/validators/schema/NamespaceScope.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:49:41 tng
* C++ Namespace Support.
*
@@ -91,9 +94,13 @@ NamespaceScope::NamespaceScope() :
, fStackCapacity(8)
, fStackTop(0)
, fStack(0)
+ , fMemoryManager(XMLPlatformUtils::fgMemoryManager)
{
// Do an initial allocation of the stack and zero it out
- fStack = new StackElem*[fStackCapacity];
+ fStack = (StackElem**) fMemoryManager->allocate
+ (
+ fStackCapacity * sizeof(StackElem*)
+ );//new StackElem*[fStackCapacity];
memset(fStack, 0, fStackCapacity * sizeof(StackElem*));
}
@@ -110,12 +117,12 @@ NamespaceScope::~NamespaceScope()
break;
// Delete the row for this entry, then delete the row structure
- delete [] fStack[stackInd]->fMap;
+ fMemoryManager->deallocate(fStack[stackInd]->fMap);//delete [] fStack[stackInd]->fMap;
delete fStack[stackInd];
}
// Delete the stack array itself now
- delete [] fStack;
+ fMemoryManager->deallocate(fStack);//delete [] fStack;
}
@@ -131,7 +138,7 @@ unsigned int NamespaceScope::increaseDepth()
// If this element has not been initialized yet, then initialize it
if (!fStack[fStackTop])
{
- fStack[fStackTop] = new StackElem;
+ fStack[fStackTop] = new (fMemoryManager) StackElem;
fStack[fStackTop]->fMapCapacity = 0;
fStack[fStackTop]->fMap = 0;
}
@@ -258,7 +265,10 @@ void NamespaceScope::expandMap(StackElem* const toExpand)
//
const unsigned int newCapacity = oldCap ?
(unsigned int)(oldCap * 1.25) : 16;
- PrefMapElem* newMap = new PrefMapElem[newCapacity];
+ PrefMapElem* newMap = (PrefMapElem*) fMemoryManager->allocate
+ (
+ newCapacity * sizeof(PrefMapElem)
+ );//new PrefMapElem[newCapacity];
//
// Copy over the old stuff. We DON'T have to zero out the new stuff
@@ -268,7 +278,7 @@ void NamespaceScope::expandMap(StackElem* const toExpand)
memcpy(newMap, toExpand->fMap, oldCap * sizeof(PrefMapElem));
// Delete the old map and store the new stuff
- delete [] toExpand->fMap;
+ fMemoryManager->deallocate(toExpand->fMap);//delete [] toExpand->fMap;
toExpand->fMap = newMap;
toExpand->fMapCapacity = newCapacity;
}
@@ -277,7 +287,10 @@ void NamespaceScope::expandStack()
{
// Expand the capacity by 25% and allocate a new buffer
const unsigned int newCapacity = (unsigned int)(fStackCapacity * 1.25);
- StackElem** newStack = new StackElem*[newCapacity];
+ StackElem** newStack = (StackElem**) fMemoryManager->allocate
+ (
+ newCapacity * sizeof(StackElem*)
+ );//new StackElem*[newCapacity];
// Copy over the old stuff
memcpy(newStack, fStack, fStackCapacity * sizeof(StackElem*));
@@ -295,7 +308,7 @@ void NamespaceScope::expandStack()
);
// Delete the old array and update our members
- delete [] fStack;
+ fMemoryManager->deallocate(fStack);//delete [] fStack;
fStack = newStack;
fStackCapacity = newCapacity;
}
diff --git a/src/xercesc/validators/schema/NamespaceScope.hpp b/src/xercesc/validators/schema/NamespaceScope.hpp
index 0c5228e50329253a526d1897eb52282290685f9d..c208c401a783d58fa9f487b414101b4dedd3b802 100644
--- a/src/xercesc/validators/schema/NamespaceScope.hpp
+++ b/src/xercesc/validators/schema/NamespaceScope.hpp
@@ -61,7 +61,6 @@
#if !defined(NAMESPACESCOPE_HPP)
#define NAMESPACESCOPE_HPP
-#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/util/StringPool.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -72,7 +71,7 @@ XERCES_CPP_NAMESPACE_BEGIN
// at a particular instant in time.
//
-class VALIDATORS_EXPORT NamespaceScope
+class VALIDATORS_EXPORT NamespaceScope : public XMemory
{
public :
// -----------------------------------------------------------------------
@@ -90,13 +89,13 @@ public :
// The fMapCapacity is how large fMap has grown so far. fMapCount
// is how many of them are valid right now.
// -----------------------------------------------------------------------
- struct PrefMapElem
+ struct PrefMapElem : public XMemory
{
unsigned int fPrefId;
unsigned int fURIId;
};
- struct StackElem
+ struct StackElem : public XMemory
{
PrefMapElem* fMap;
unsigned int fMapCapacity;
@@ -174,6 +173,7 @@ private :
unsigned int fStackTop;
XMLStringPool fPrefixPool;
StackElem** fStack;
+ MemoryManager* fMemoryManager;
};
diff --git a/src/xercesc/validators/schema/SchemaElementDecl.cpp b/src/xercesc/validators/schema/SchemaElementDecl.cpp
index 339d1fd4db00627c5ad4377567267cf0e77fbf07..47d55d5ef31e3a405f7ba5f8f38613d5db0893db 100644
--- a/src/xercesc/validators/schema/SchemaElementDecl.cpp
+++ b/src/xercesc/validators/schema/SchemaElementDecl.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.8 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.7 2003/01/29 19:47:16 gareth
* added DOMTypeInfo and some PSVI methods
*
@@ -151,9 +154,9 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// SchemaElementDecl: Constructors and Destructor
// ---------------------------------------------------------------------------
-SchemaElementDecl::SchemaElementDecl() :
-
- fModelType(Any)
+SchemaElementDecl::SchemaElementDecl(MemoryManager* const manager) :
+ XMLElementDecl(manager)
+ , fModelType(Any)
, fDatatypeValidator(0)
, fEnclosingScope(Grammar::TOP_LEVEL_SCOPE)
, fBlockSet(0)
@@ -180,8 +183,9 @@ SchemaElementDecl::SchemaElementDecl(const XMLCh* const prefix
, const int uriId
, const SchemaElementDecl::ModelTypes type
, const int enclosingScope
- ) :
- fModelType(type)
+ , MemoryManager* const manager) :
+ XMLElementDecl(manager)
+ , fModelType(type)
, fDatatypeValidator(0)
, fEnclosingScope(enclosingScope)
, fBlockSet(0)
@@ -207,8 +211,9 @@ SchemaElementDecl::SchemaElementDecl(const XMLCh* const prefix
SchemaElementDecl::SchemaElementDecl(const QName* const elementName
, const SchemaElementDecl::ModelTypes type
, const int enclosingScope
- ) :
- fModelType(type)
+ , MemoryManager* const manager) :
+ XMLElementDecl(manager)
+ , fModelType(type)
, fDatatypeValidator(0)
, fEnclosingScope(enclosingScope)
, fBlockSet(0)
@@ -233,7 +238,7 @@ SchemaElementDecl::SchemaElementDecl(const QName* const element
SchemaElementDecl::~SchemaElementDecl()
{
- delete [] fDefaultValue;
+ getMemoryManager()->deallocate(fDefaultValue);//delete [] fDefaultValue;
delete fAttDefs;
delete fIdentityConstraints;
delete fAttWildCard;
@@ -263,7 +268,7 @@ XMLAttDef* SchemaElementDecl::findAttr(const XMLCh* const qName
// If no att list exist yet, then create one
if (!fAttDefs) {
// Use a hash modulus of 29 and tell it owns its elements
- ((SchemaElementDecl*)this)->fAttDefs = new RefHash2KeysTableOf<SchemaAttDef>(29, true);
+ ((SchemaElementDecl*)this)->fAttDefs = new (getMemoryManager()) RefHash2KeysTableOf<SchemaAttDef>(29, true);
}
retVal = fAttDefs->get(baseName, uriId);
@@ -272,7 +277,7 @@ XMLAttDef* SchemaElementDecl::findAttr(const XMLCh* const qName
if (!retVal)
{
// And add a default attribute for this name
- retVal = new SchemaAttDef(prefix, baseName, uriId);
+ retVal = new (getMemoryManager()) SchemaAttDef(prefix, baseName, uriId);
retVal->setElemId(getId());
fAttDefs->put((void*)retVal->getAttName()->getLocalPart(), uriId, retVal);
diff --git a/src/xercesc/validators/schema/SchemaElementDecl.hpp b/src/xercesc/validators/schema/SchemaElementDecl.hpp
index d48272d5b85a261e7d0a54246617a95073b8af73..2d7eb574071621f1df257d058df66581ec5bfaf6 100644
--- a/src/xercesc/validators/schema/SchemaElementDecl.hpp
+++ b/src/xercesc/validators/schema/SchemaElementDecl.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.9 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.8 2003/01/29 19:47:16 gareth
* added DOMTypeInfo and some PSVI methods
*
@@ -179,22 +182,23 @@ public :
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- SchemaElementDecl();
-
+ SchemaElementDecl(MemoryManager* const manager);
SchemaElementDecl
(
- const XMLCh* const prefix
- , const XMLCh* const localPart
- , const int uriId
- , const ModelTypes modelType = Any
- , const int enclosingScope = Grammar::TOP_LEVEL_SCOPE
+ const XMLCh* const prefix
+ , const XMLCh* const localPart
+ , const int uriId
+ , const ModelTypes modelType// = Any
+ , const int enclosingScope// = Grammar::TOP_LEVEL_SCOPE
+ , MemoryManager* const manager
);
SchemaElementDecl
(
- const QName* const elementName
- , const ModelTypes modelType = Any
- , const int enclosingScope = Grammar::TOP_LEVEL_SCOPE
+ const QName* const elementName
+ , const ModelTypes modelType// = Any
+ , const int enclosingScope// = Grammar::TOP_LEVEL_SCOPE
+ , MemoryManager* const manager
);
~SchemaElementDecl();
@@ -783,10 +787,10 @@ inline void SchemaElementDecl::setMiscFlags(const int flags)
inline void SchemaElementDecl::setDefaultValue(const XMLCh* const value)
{
if (fDefaultValue) {
- delete[] fDefaultValue;
+ getMemoryManager()->deallocate(fDefaultValue);//delete[] fDefaultValue;
}
- fDefaultValue = XMLString::replicate(value);
+ fDefaultValue = XMLString::replicate(value, getMemoryManager());
}
inline void
diff --git a/src/xercesc/validators/schema/SchemaGrammar.cpp b/src/xercesc/validators/schema/SchemaGrammar.cpp
index 5df70a996063128dbddefc684da543dfd942a802..b19d97f679673d2408ccde5842ecd0443c52343b 100644
--- a/src/xercesc/validators/schema/SchemaGrammar.cpp
+++ b/src/xercesc/validators/schema/SchemaGrammar.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/11/04 14:49:41 tng
* C++ Namespace Support.
*
@@ -117,7 +120,7 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// SchemaGrammar: Constructors and Destructor
// ---------------------------------------------------------------------------
-SchemaGrammar::SchemaGrammar() :
+SchemaGrammar::SchemaGrammar(MemoryManager* const manager) :
fTargetNamespace(0)
, fElemDeclPool(0)
, fElemNonDeclPool(0)
@@ -130,7 +133,9 @@ SchemaGrammar::SchemaGrammar() :
, fNamespaceScope(0)
, fValidSubstitutionGroups(0)
, fIDRefList(0)
+ , fMemoryManager(manager)
, fValidated(false)
+ , fDatatypeRegistry(manager)
{
//
// Init all the pool members.
@@ -138,13 +143,13 @@ SchemaGrammar::SchemaGrammar() :
// <TBD> Investigate what the optimum values would be for the various
// pools.
//
- fElemDeclPool = new RefHash3KeysIdPool<SchemaElementDecl>(109);
+ fElemDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(109);
try {
- fElemNonDeclPool = new RefHash3KeysIdPool<SchemaElementDecl>(29);
- fGroupElemDeclPool = new RefHash3KeysIdPool<SchemaElementDecl>(109, false);
+ fElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29);
+ fGroupElemDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(109, false);
fNotationDeclPool = new NameIdPool<XMLNotationDecl>(109);
- fIDRefList = new RefHashTableOf<XMLRefInfo>(29);
+ fIDRefList = new (fMemoryManager) RefHashTableOf<XMLRefInfo>(29);
fDatatypeRegistry.expandRegistryToFullSchemaSet();
//
@@ -183,7 +188,15 @@ XMLElementDecl* SchemaGrammar::findOrAddElemDecl (const unsigned int uriId
// if not, then add this in
if (!retVal)
{
- retVal = new SchemaElementDecl(prefixName, baseName, uriId, SchemaElementDecl::Any);
+ retVal = new (fMemoryManager) SchemaElementDecl
+ (
+ prefixName
+ , baseName
+ , uriId
+ , SchemaElementDecl::Any
+ , Grammar::TOP_LEVEL_SCOPE
+ , fMemoryManager
+ );
const unsigned int elemId = fElemNonDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal);
retVal->setId(elemId);
wasAdded = true;
@@ -202,7 +215,15 @@ XMLElementDecl* SchemaGrammar::putElemDecl (const unsigned int uriId
, unsigned int scope
, const bool notDeclared)
{
- SchemaElementDecl* retVal = new SchemaElementDecl(prefixName, baseName, uriId, SchemaElementDecl::Any);
+ SchemaElementDecl* retVal = new (fMemoryManager) SchemaElementDecl
+ (
+ prefixName
+ , baseName
+ , uriId
+ , SchemaElementDecl::Any
+ , Grammar::TOP_LEVEL_SCOPE
+ , fMemoryManager
+ );
const unsigned int elemId = (notDeclared) ? fElemNonDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal)
: fElemDeclPool->put((void*)retVal->getBaseName(), uriId, scope, retVal);
retVal->setId(elemId);
@@ -228,7 +249,7 @@ void SchemaGrammar::cleanUp()
delete fElemNonDeclPool;
delete fGroupElemDeclPool;
delete fNotationDeclPool;
- delete [] fTargetNamespace;
+ fMemoryManager->deallocate(fTargetNamespace);//delete [] fTargetNamespace;
delete fAttributeDeclRegistry;
delete fComplexTypeRegistry;
delete fGroupInfoRegistry;
diff --git a/src/xercesc/validators/schema/SchemaGrammar.hpp b/src/xercesc/validators/schema/SchemaGrammar.hpp
index 4567cdc721278852f4e9775883dc91753a7d86c4..376e4ee431d71cf53369e90daee8914441c9d107 100644
--- a/src/xercesc/validators/schema/SchemaGrammar.hpp
+++ b/src/xercesc/validators/schema/SchemaGrammar.hpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/11/04 14:49:41 tng
* C++ Namespace Support.
*
@@ -159,7 +162,7 @@ public:
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- SchemaGrammar();
+ SchemaGrammar(MemoryManager* const manager);
virtual ~SchemaGrammar();
// -----------------------------------------------------------------------
@@ -351,11 +354,12 @@ private:
RefHashTableOf<ComplexTypeInfo>* fComplexTypeRegistry;
RefHashTableOf<XercesGroupInfo>* fGroupInfoRegistry;
RefHashTableOf<XercesAttGroupInfo>* fAttGroupInfoRegistry;
- DatatypeValidatorFactory fDatatypeRegistry;
NamespaceScope* fNamespaceScope;
RefHash2KeysTableOf<ElemVector>* fValidSubstitutionGroups;
RefHashTableOf<XMLRefInfo>* fIDRefList;
+ MemoryManager* fMemoryManager;
bool fValidated;
+ DatatypeValidatorFactory fDatatypeRegistry;
};
@@ -415,9 +419,11 @@ inline RefHashTableOf<XMLRefInfo>* SchemaGrammar::getIDRefList() const {
// -----------------------------------------------------------------------
// Setter methods
// -----------------------------------------------------------------------
-inline void SchemaGrammar::setTargetNamespace(const XMLCh* const targetNamespace) {
- delete [] fTargetNamespace;
- fTargetNamespace = XMLString::replicate(targetNamespace);
+inline void SchemaGrammar::setTargetNamespace(const XMLCh* const targetNamespace)
+{
+ if (fTargetNamespace)
+ fMemoryManager->deallocate(fTargetNamespace);//delete [] fTargetNamespace;
+ fTargetNamespace = XMLString::replicate(targetNamespace, fMemoryManager);
}
inline void
diff --git a/src/xercesc/validators/schema/SchemaInfo.hpp b/src/xercesc/validators/schema/SchemaInfo.hpp
index 04b1335eb0279ed2f7c6183b9a5d8043ac4e2feb..3888ac57379a33eb91e470c50c6c6edb56db8ba9 100644
--- a/src/xercesc/validators/schema/SchemaInfo.hpp
+++ b/src/xercesc/validators/schema/SchemaInfo.hpp
@@ -83,7 +83,7 @@
XERCES_CPP_NAMESPACE_BEGIN
-class VALIDATORS_EXPORT SchemaInfo
+class VALIDATORS_EXPORT SchemaInfo : public XMemory
{
public:
diff --git a/src/xercesc/validators/schema/SchemaValidator.cpp b/src/xercesc/validators/schema/SchemaValidator.cpp
index 7883ceb43f483ed744c529279b3dcdd12a416bf6..ab547d9cd8008c2a85c1d8cb21ceb916b6b8ae46 100644
--- a/src/xercesc/validators/schema/SchemaValidator.cpp
+++ b/src/xercesc/validators/schema/SchemaValidator.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.29 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.28 2003/02/06 13:51:55 gareth
* fixed bug with multiple attributes being validated by the same union type.
*
@@ -251,9 +254,11 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// SchemaValidator: Constructors and Destructor
// ---------------------------------------------------------------------------
-SchemaValidator::SchemaValidator(XMLErrorReporter* const errReporter) :
+SchemaValidator::SchemaValidator( XMLErrorReporter* const errReporter
+ , MemoryManager* const manager) :
XMLValidator(errReporter)
+ , fMemoryManager(manager)
, fGrammarResolver(0)
, fSchemaGrammar(0)
, fTrailing(false)
diff --git a/src/xercesc/validators/schema/SchemaValidator.hpp b/src/xercesc/validators/schema/SchemaValidator.hpp
index 157af4ded67c8c8cb542d0c5f0442bae94a667af..47af4c384beb084d548149997d95b4d1dac4a8cd 100644
--- a/src/xercesc/validators/schema/SchemaValidator.hpp
+++ b/src/xercesc/validators/schema/SchemaValidator.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.14 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.13 2003/01/20 19:04:48 knoaman
* Fix for particle derivation checking.
*
@@ -135,19 +138,19 @@
#if !defined(SCHEMAVALIDATOR_HPP)
#define SCHEMAVALIDATOR_HPP
-#include <xercesc/framework/XMLBuffer.hpp>
#include <xercesc/framework/XMLValidator.hpp>
-#include <xercesc/util/RefVectorOf.hpp>
+#include <xercesc/framework/XMLBuffer.hpp>
#include <xercesc/util/ValueStackOf.hpp>
-#include <xercesc/validators/common/GrammarResolver.hpp>
#include <xercesc/validators/common/ContentSpecNode.hpp>
-#include <xercesc/validators/datatype/DatatypeValidator.hpp>
-#include <xercesc/validators/schema/SchemaElementDecl.hpp>
#include <xercesc/validators/schema/SchemaGrammar.hpp>
#include <xercesc/validators/schema/XSDErrorReporter.hpp>
XERCES_CPP_NAMESPACE_BEGIN
+class GrammarResolver;
+class DatatypeValidator;
+class SchemaElementDecl;
+
//
// This is a derivative of the abstract validator interface. This class
// implements a validator that supports standard XML Schema semantics.
@@ -160,7 +163,11 @@ public:
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
- SchemaValidator(XMLErrorReporter* const errReporter = 0);
+ SchemaValidator
+ (
+ XMLErrorReporter* const errReporter// = 0
+ , MemoryManager* const manager
+ );
virtual ~SchemaValidator();
// -----------------------------------------------------------------------
@@ -368,17 +375,16 @@ private:
// fTypeStack
// Stack of complex type declarations.
// -----------------------------------------------------------------------
- SchemaGrammar* fSchemaGrammar;
- GrammarResolver* fGrammarResolver;
- QName* fXsiType;
- bool fNil;
-
- DatatypeValidator* fXsiTypeValidator;
-
- XMLBuffer fDatatypeBuffer;
- bool fTrailing;
- bool fSeenId;
- XSDErrorReporter fSchemaErrorReporter;
+ MemoryManager* fMemoryManager;
+ SchemaGrammar* fSchemaGrammar;
+ GrammarResolver* fGrammarResolver;
+ QName* fXsiType;
+ bool fNil;
+ DatatypeValidator* fXsiTypeValidator;
+ XMLBuffer fDatatypeBuffer;
+ bool fTrailing;
+ bool fSeenId;
+ XSDErrorReporter fSchemaErrorReporter;
ValueStackOf<ComplexTypeInfo*>* fTypeStack;
};
diff --git a/src/xercesc/validators/schema/TraverseSchema.cpp b/src/xercesc/validators/schema/TraverseSchema.cpp
index 55462867c441f3429c91487350c368778fe319d7..ac3c0eea4152be90fe6468d732a133068a9951dc 100644
--- a/src/xercesc/validators/schema/TraverseSchema.cpp
+++ b/src/xercesc/validators/schema/TraverseSchema.cpp
@@ -195,7 +195,8 @@ TraverseSchema::TraverseSchema( DOMElement* const schemaRoot
, XMLScanner* const xmlScanner
, const XMLCh* const schemaURL
, XMLEntityHandler* const entityHandler
- , XMLErrorReporter* const errorReporter)
+ , XMLErrorReporter* const errorReporter
+ , MemoryManager* const manager)
: fFullConstraintChecking(false)
, fTargetNSURI(-1)
, fEmptyNamespaceURI(-1)
@@ -238,6 +239,8 @@ TraverseSchema::TraverseSchema( DOMElement* const schemaRoot
, fParser(0)
, fPreprocessedNodes(0)
, fLocator(0)
+ , fMemoryManager(manager)
+ , fAttributeCheck(manager)
{
try {
@@ -318,7 +321,7 @@ void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot,
if (fComplexTypeRegistry == 0 ) {
- fComplexTypeRegistry = new RefHashTableOf<ComplexTypeInfo>(29);
+ fComplexTypeRegistry = new (fMemoryManager) RefHashTableOf<ComplexTypeInfo>(29);
fSchemaGrammar->setComplexTypeRegistry(fComplexTypeRegistry);
}
@@ -326,7 +329,7 @@ void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot,
if (fGroupRegistry == 0 ) {
- fGroupRegistry = new RefHashTableOf<XercesGroupInfo>(13);
+ fGroupRegistry = new (fMemoryManager) RefHashTableOf<XercesGroupInfo>(13);
fSchemaGrammar->setGroupInfoRegistry(fGroupRegistry);
}
@@ -334,7 +337,7 @@ void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot,
if (fAttGroupRegistry == 0 ) {
- fAttGroupRegistry = new RefHashTableOf<XercesAttGroupInfo>(13);
+ fAttGroupRegistry = new (fMemoryManager) RefHashTableOf<XercesAttGroupInfo>(13);
fSchemaGrammar->setAttGroupInfoRegistry(fAttGroupRegistry);
}
@@ -342,7 +345,7 @@ void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot,
if (fAttributeDeclRegistry == 0) {
- fAttributeDeclRegistry = new RefHashTableOf<XMLAttDef>(29);
+ fAttributeDeclRegistry = new (fMemoryManager) RefHashTableOf<XMLAttDef>(29);
fSchemaGrammar->setAttributeDeclRegistry(fAttributeDeclRegistry);
}
@@ -350,7 +353,7 @@ void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot,
if (fNamespaceScope == 0) {
- fNamespaceScope = new NamespaceScope();
+ fNamespaceScope = new (fMemoryManager) NamespaceScope();
fNamespaceScope->reset(fEmptyNamespaceURI);
fSchemaGrammar->setNamespaceScope(fNamespaceScope);
}
@@ -359,7 +362,7 @@ void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot,
if (!fValidSubstitutionGroups) {
- fValidSubstitutionGroups = new RefHash2KeysTableOf<ElemVector>(29);
+ fValidSubstitutionGroups = new (fMemoryManager) RefHash2KeysTableOf<ElemVector>(29);
fSchemaGrammar->setValidSubstitutionGroups(fValidSubstitutionGroups);
}
@@ -375,7 +378,7 @@ void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot,
fAttributeCheck.setIDRefList(fSchemaGrammar->getIDRefList());
// Save current schema info
- SchemaInfo* currInfo = new SchemaInfo(0, 0, 0, fTargetNSURI, fScopeCount,
+ SchemaInfo* currInfo = new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI, fScopeCount,
fNamespaceScope->increaseDepth(),
XMLString::replicate(schemaURL),
fTargetNSURIString, schemaRoot);
@@ -513,7 +516,7 @@ void TraverseSchema::preprocessInclude(const DOMElement* const elem) {
// Parse input source
// ------------------------------------------------------------------
if (!fParser)
- fParser = new XSDDOMParser;
+ fParser = new (fMemoryManager) XSDDOMParser;
fParser->setValidationScheme(XercesDOMParser::Val_Never);
fParser->setDoNamespaces(true);
@@ -565,7 +568,7 @@ void TraverseSchema::preprocessInclude(const DOMElement* const elem) {
// --------------------------------------------------------
SchemaInfo* saveInfo = fSchemaInfo;
- fSchemaInfo = new SchemaInfo(0, 0, 0, fTargetNSURI, fScopeCount,
+ fSchemaInfo = new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI, fScopeCount,
fNamespaceScope->increaseDepth(),
XMLString::replicate(includeURL),
fTargetNSURIString, root);
@@ -691,7 +694,7 @@ void TraverseSchema::preprocessImport(const DOMElement* const elem) {
// Parse input source
// ------------------------------------------------------------------
if (!fParser)
- fParser = new XSDDOMParser;
+ fParser = new (fMemoryManager) XSDDOMParser;
fParser->setValidationScheme(XercesDOMParser::Val_Never);
fParser->setDoNamespaces(true);
@@ -735,7 +738,7 @@ void TraverseSchema::preprocessImport(const DOMElement* const elem) {
// Preprocess new schema
// --------------------------------------------------------
SchemaInfo* saveInfo = fSchemaInfo;
- fSchemaGrammar = new SchemaGrammar();
+ fSchemaGrammar = new (fMemoryManager) SchemaGrammar(fMemoryManager);
preprocessSchema(root, importURL);
fPreprocessedNodes->put((void*) elem, fSchemaInfo);
@@ -804,7 +807,7 @@ void TraverseSchema::preprocessRedefine(const DOMElement* const redefineElem) {
}
if (!fRedefineComponents) {
- fRedefineComponents = new RefHash2KeysTableOf<XMLCh>(13, false);
+ fRedefineComponents = new (fMemoryManager) RefHash2KeysTableOf<XMLCh>(13, false);
}
SchemaInfo* redefinedInfo = fSchemaInfo;
@@ -882,7 +885,7 @@ TraverseSchema::traverseChoiceSequence(const DOMElement* const elem,
continue;
}
- contentSpecNode = new ContentSpecNode(eltQName, false);
+ contentSpecNode = new (fMemoryManager) ContentSpecNode(eltQName, false);
seeParticle = true;
}
else if (XMLString::equals(childName, SchemaSymbols::fgELT_GROUP)) {
@@ -905,7 +908,7 @@ TraverseSchema::traverseChoiceSequence(const DOMElement* const elem,
continue;
}
- contentSpecNode = new ContentSpecNode(*contentSpecNode);
+ contentSpecNode = new (fMemoryManager) ContentSpecNode(*contentSpecNode);
seeParticle = true;
}
else if (XMLString::equals(childName, SchemaSymbols::fgELT_CHOICE)) {
@@ -942,13 +945,13 @@ TraverseSchema::traverseChoiceSequence(const DOMElement* const elem,
right = contentSpecNode;
}
else {
- left = new ContentSpecNode((ContentSpecNode::NodeTypes) modelGroupType, left, right);
+ left = new (fMemoryManager) ContentSpecNode((ContentSpecNode::NodeTypes) modelGroupType, left, right);
right = contentSpecNode;
}
}
if (hadContent) {
- left = new ContentSpecNode((ContentSpecNode::NodeTypes) modelGroupType, left, right);
+ left = new (fMemoryManager) ContentSpecNode((ContentSpecNode::NodeTypes) modelGroupType, left, right);
}
return left;
@@ -1163,7 +1166,7 @@ int TraverseSchema::traverseComplexTypeDecl(const DOMElement* const elem,
// ------------------------------------------------------------------
// Register the type
// ------------------------------------------------------------------
- typeInfo = new ComplexTypeInfo();
+ typeInfo = new (fMemoryManager) ComplexTypeInfo(fMemoryManager);
if(isAnonymous) {
typeInfo->setAnonymous();
}
@@ -1366,7 +1369,7 @@ TraverseSchema::traverseGroupDecl(const DOMElement* const elem,
ContentSpecNode* specNode = 0;
XercesGroupInfo* saveGroupInfo = fCurrentGroupInfo;
- groupInfo = new XercesGroupInfo();
+ groupInfo = new (fMemoryManager) XercesGroupInfo(fMemoryManager);
fCurrentGroupStack->addElement(nameIndex);
fCurrentGroupInfo = groupInfo;
@@ -1512,7 +1515,7 @@ TraverseSchema::traverseAttributeGroupDecl(const DOMElement* const elem,
// Process contents of global attributeGroups
// ------------------------------------------------------------------
XercesAttGroupInfo* saveAttGroupInfo = fCurrentAttGroupInfo;
- XercesAttGroupInfo* attGroupInfo = new XercesAttGroupInfo();
+ XercesAttGroupInfo* attGroupInfo = new (fMemoryManager) XercesAttGroupInfo(fMemoryManager);
fDeclStack->addElement(elem);
fCurrentAttGroupInfo = attGroupInfo;
@@ -1671,14 +1674,14 @@ TraverseSchema::traverseAny(const DOMElement* const elem) {
if ((!nameSpace || !*nameSpace)
|| XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDANY)) {
- retSpecNode = new ContentSpecNode(new QName(XMLUni::fgZeroLenString,
+ retSpecNode = new (fMemoryManager) ContentSpecNode(new (fMemoryManager) QName(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
fEmptyNamespaceURI),
false);
retSpecNode->setType(anyType);
}
else if (XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDOTHER)) {
- retSpecNode = new ContentSpecNode(new QName(XMLUni::fgZeroLenString,
+ retSpecNode = new (fMemoryManager) ContentSpecNode(new (fMemoryManager) QName(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
fTargetNSURI),
false);
@@ -1720,7 +1723,7 @@ TraverseSchema::traverseAny(const DOMElement* const elem) {
uriList.addElement(uriIndex);
- firstNode = new ContentSpecNode(new QName(XMLUni::fgZeroLenString,
+ firstNode = new (fMemoryManager) ContentSpecNode(new (fMemoryManager) QName(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
uriIndex),
false);
@@ -1730,7 +1733,7 @@ TraverseSchema::traverseAny(const DOMElement* const elem) {
secondNode = firstNode;
}
else {
- secondNode = new ContentSpecNode(ContentSpecNode::Choice, secondNode, firstNode);
+ secondNode = new (fMemoryManager) ContentSpecNode(ContentSpecNode::Choice, secondNode, firstNode);
}
}
@@ -1787,7 +1790,7 @@ TraverseSchema::traverseAll(const DOMElement* const elem) {
continue;
}
- contentSpecNode = new ContentSpecNode(eltQName, false);
+ contentSpecNode = new (fMemoryManager) ContentSpecNode(eltQName, false);
checkMinMax(contentSpecNode, child, All_Element);
}
else {
@@ -1805,13 +1808,13 @@ TraverseSchema::traverseAll(const DOMElement* const elem) {
right = contentSpecNode;
}
else {
- left = new ContentSpecNode(ContentSpecNode::All, left, right);
+ left = new (fMemoryManager) ContentSpecNode(ContentSpecNode::All, left, right);
right = contentSpecNode;
}
}
if (hadContent) {
- left = new ContentSpecNode(ContentSpecNode::All, left, right);
+ left = new (fMemoryManager) ContentSpecNode(ContentSpecNode::All, left, right);
}
return left;
@@ -2114,7 +2117,7 @@ void TraverseSchema::traverseAttributeDecl(const DOMElement* const elem,
}
// create SchemaAttDef
- SchemaAttDef* attDef = new SchemaAttDef(XMLUni::fgZeroLenString, name, uriIndex, attType);
+ SchemaAttDef* attDef = new (fMemoryManager) SchemaAttDef(XMLUni::fgZeroLenString, name, uriIndex, attType);
attDef->setDatatypeValidator(dv);
@@ -2209,7 +2212,7 @@ QName* TraverseSchema::traverseElementDecl(const DOMElement* const elem,
if (topLevel) {
if (fSchemaGrammar->getElemDecl(fTargetNSURI, name, 0, Grammar::TOP_LEVEL_SCOPE) != 0) {
- return new QName(name, fTargetNSURI);
+ return new (fMemoryManager) QName(name, fTargetNSURI);
}
}
@@ -2450,20 +2453,20 @@ QName* TraverseSchema::traverseElementDecl(const DOMElement* const elem,
subsElements = aGrammar->getValidSubstitutionGroups()->get(subsElemBaseName, subsElemURI);
if (subsElements) {
- subsElements = new ValueVectorOf<SchemaElementDecl*>(*subsElements);
+ subsElements = new (fMemoryManager) ValueVectorOf<SchemaElementDecl*>(*subsElements);
fValidSubstitutionGroups->put(subsElemBaseName, subsElemURI, subsElements);
}
else if (fSchemaInfo->circularImportExist(subsElemURI)) {
aGrammar->getValidSubstitutionGroups()->put(
- subsElemBaseName, subsElemURI, new ValueVectorOf<SchemaElementDecl*>(8));
+ subsElemBaseName, subsElemURI, new (fMemoryManager) ValueVectorOf<SchemaElementDecl*>(8));
}
}
}
if (!subsElements) {
- subsElements = new ValueVectorOf<SchemaElementDecl*>(8);
+ subsElements = new (fMemoryManager) ValueVectorOf<SchemaElementDecl*>(8);
fValidSubstitutionGroups->put(subsElemBaseName, subsElemURI, subsElements);
}
@@ -2585,7 +2588,7 @@ QName* TraverseSchema::traverseElementDecl(const DOMElement* const elem,
elemDecl->setContentSpec(contentSpecNode);
if (isAnyType) {
- elemDecl->setAttWildCard(new SchemaAttDef(XMLUni::fgZeroLenString,
+ elemDecl->setAttWildCard(new (fMemoryManager) SchemaAttDef(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
fEmptyNamespaceURI, XMLAttDef::Any_Any,
XMLAttDef::ProcessContents_Lax));
@@ -2607,7 +2610,7 @@ QName* TraverseSchema::traverseElementDecl(const DOMElement* const elem,
else {
if (!icNodes) {
- icNodes = new ValueVectorOf<DOMElement*>(8);
+ icNodes = new (fMemoryManager) ValueVectorOf<DOMElement*>(8);
}
icNodes->addElement(ic);
@@ -2621,9 +2624,9 @@ QName* TraverseSchema::traverseElementDecl(const DOMElement* const elem,
if (!fIC_ElementsNS) {
- fIC_ElementsNS = new RefHashTableOf<ElemVector>(13);
- fIC_NamespaceDepthNS = new RefHashTableOf<ValueVectorOf<unsigned int> >(13);
- fIC_NodeListNS = new RefHashTableOf<ValueVectorOf<DOMElement*> >(29, true, new HashPtr());
+ fIC_ElementsNS = new (fMemoryManager) RefHashTableOf<ElemVector>(13);
+ fIC_NamespaceDepthNS = new (fMemoryManager) RefHashTableOf<ValueVectorOf<unsigned int> >(13);
+ fIC_NodeListNS = new (fMemoryManager) RefHashTableOf<ValueVectorOf<DOMElement*> >(29, true, new (fMemoryManager) HashPtr());
}
if (fIC_ElementsNS->containsKey(fTargetNSURIString)) {
@@ -2634,8 +2637,8 @@ QName* TraverseSchema::traverseElementDecl(const DOMElement* const elem,
if (!fIC_Elements) {
- fIC_Elements = new ValueVectorOf<SchemaElementDecl*>(8);
- fIC_NamespaceDepth = new ValueVectorOf<unsigned int>(8);
+ fIC_Elements = new (fMemoryManager) ValueVectorOf<SchemaElementDecl*>(8);
+ fIC_NamespaceDepth = new (fMemoryManager) ValueVectorOf<unsigned int>(8);
fIC_ElementsNS->put((void*) fTargetNSURIString, fIC_Elements);
fIC_NamespaceDepthNS->put((void*) fTargetNSURIString, fIC_NamespaceDepth);
}
@@ -2646,7 +2649,7 @@ QName* TraverseSchema::traverseElementDecl(const DOMElement* const elem,
}
}
- return new QName(*elemDecl->getElementName());
+ return new (fMemoryManager) QName(*elemDecl->getElementName());
}
const XMLCh* TraverseSchema::traverseNotationDecl(const DOMElement* const elem) {
@@ -2904,7 +2907,7 @@ TraverseSchema::traverseByRestriction(const DOMElement* const rootElem,
fAttributeCheck.checkAttributes(content, scope, this);
if (facets == 0) {
- facets = new RefHashTableOf<KVStringPair>(29, true);
+ facets = new (fMemoryManager) RefHashTableOf<KVStringPair>(29, true);
}
if (XMLString::equals(facetName, SchemaSymbols::fgELT_ENUMERATION)) {
@@ -2914,7 +2917,7 @@ TraverseSchema::traverseByRestriction(const DOMElement* const rootElem,
// to get the qualified name first before adding it to the
// enum buffer
if (!enums) {
- enums = new RefArrayVectorOf<XMLCh>(8, true);
+ enums = new (fMemoryManager) RefArrayVectorOf<XMLCh>(8, true);
}
if (baseValidator->getType() == DatatypeValidator::NOTATION) {
@@ -2965,7 +2968,7 @@ TraverseSchema::traverseByRestriction(const DOMElement* const rootElem,
else {
const XMLCh* facetStr = fStringPool->getValueForId(fStringPool->addOrFind(facetName));
- facets->put((void*) facetStr, new KVStringPair(facetStr, attValue));
+ facets->put((void*) facetStr, new (fMemoryManager) KVStringPair(facetStr, attValue));
checkFixedFacet(content, facetStr, baseValidator, fixedFlag);
}
}
@@ -2982,14 +2985,14 @@ TraverseSchema::traverseByRestriction(const DOMElement* const rootElem,
if (!pattern.isEmpty()) {
facets->put((void*) SchemaSymbols::fgELT_PATTERN,
- new KVStringPair(SchemaSymbols::fgELT_PATTERN, pattern.getRawBuffer()));
+ new (fMemoryManager) KVStringPair(SchemaSymbols::fgELT_PATTERN, pattern.getRawBuffer()));
}
if (fixedFlag) {
XMLString::binToText(fixedFlag, fixedFlagStr, 15, 10);
facets->put((void*) SchemaSymbols::fgATT_FIXED,
- new KVStringPair(SchemaSymbols::fgATT_FIXED, fixedFlagStr));
+ new (fMemoryManager) KVStringPair(SchemaSymbols::fgATT_FIXED, fixedFlagStr));
}
try {
@@ -3026,7 +3029,7 @@ TraverseSchema::traverseByUnion(const DOMElement* const rootElem,
int size = 1;
const XMLCh* baseTypeName = getElementAttValue(contentElem, SchemaSymbols::fgATT_MEMBERTYPES);
DatatypeValidator* baseValidator = 0;
- RefVectorOf<DatatypeValidator>* validators = new RefVectorOf<DatatypeValidator>(4, false);
+ RefVectorOf<DatatypeValidator>* validators = new (fMemoryManager) RefVectorOf<DatatypeValidator>(4, false);
Janitor<DVRefVector> janValidators(validators);
DOMElement* content = 0;
@@ -3343,13 +3346,13 @@ void TraverseSchema::traverseSimpleContentDecl(const XMLCh* const typeName,
const XMLCh* attValue = content->getAttribute(SchemaSymbols::fgATT_VALUE);
if (facets == 0) {
- facets = new RefHashTableOf<KVStringPair>(29, true);
+ facets = new (fMemoryManager) RefHashTableOf<KVStringPair>(29, true);
}
if (XMLString::equals(facetName, SchemaSymbols::fgELT_ENUMERATION)) {
if (!enums) {
- enums = new RefArrayVectorOf<XMLCh>(8, true);
+ enums = new (fMemoryManager) RefArrayVectorOf<XMLCh>(8, true);
}
enums->addElement(XMLString::replicate(attValue));
@@ -3377,7 +3380,7 @@ void TraverseSchema::traverseSimpleContentDecl(const XMLCh* const typeName,
const XMLCh* facetNameStr =
fStringPool->getValueForId(fStringPool->addOrFind(facetName));
- facets->put((void*) facetNameStr, new KVStringPair(facetNameStr, attValue));
+ facets->put((void*) facetNameStr, new (fMemoryManager) KVStringPair(facetNameStr, attValue));
checkFixedFacet(content, facetNameStr, typeInfo->getBaseDatatypeValidator(), fixedFlag);
}
}
@@ -3392,7 +3395,7 @@ void TraverseSchema::traverseSimpleContentDecl(const XMLCh* const typeName,
facets->put
(
(void*) SchemaSymbols::fgELT_PATTERN,
- new KVStringPair
+ new (fMemoryManager) KVStringPair
(
SchemaSymbols::fgELT_PATTERN,
pattern.getRawBuffer()
@@ -3404,7 +3407,7 @@ void TraverseSchema::traverseSimpleContentDecl(const XMLCh* const typeName,
XMLString::binToText(fixedFlag, fixedFlagStr, 15, 10);
facets->put((void*) SchemaSymbols::fgATT_FIXED,
- new KVStringPair(SchemaSymbols::fgATT_FIXED, fixedFlagStr));
+ new (fMemoryManager) KVStringPair(SchemaSymbols::fgATT_FIXED, fixedFlagStr));
}
try {
@@ -3707,7 +3710,7 @@ SchemaAttDef* TraverseSchema::traverseAnyAttribute(const DOMElement* const elem)
// ------------------------------------------------------------------
// Create wildcard attribute
// ------------------------------------------------------------------
- SchemaAttDef* attDef = new SchemaAttDef(XMLUni::fgZeroLenString,
+ SchemaAttDef* attDef = new (fMemoryManager) SchemaAttDef(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
uriIndex, attType, attDefType);
@@ -3751,7 +3754,7 @@ void TraverseSchema::traverseKey(const DOMElement* const icElem,
if (!fIdentityConstraintNames) {
- fIdentityConstraintNames = new RefHash2KeysTableOf<IdentityConstraint>(29, false);
+ fIdentityConstraintNames = new (fMemoryManager) RefHash2KeysTableOf<IdentityConstraint>(29, false);
}
if (fIdentityConstraintNames->containsKey(name, fTargetNSURI)) {
@@ -3760,7 +3763,7 @@ void TraverseSchema::traverseKey(const DOMElement* const icElem,
return;
}
- IC_Key* icKey = new IC_Key(name, elemDecl->getBaseName());
+ IC_Key* icKey = new (fMemoryManager) IC_Key(name, elemDecl->getBaseName(), fMemoryManager);
Janitor<IC_Key> janKey(icKey);
fIdentityConstraintNames->put((void*) name, fTargetNSURI, icKey);
@@ -3812,7 +3815,7 @@ void TraverseSchema::traverseUnique(const DOMElement* const icElem,
}
if (!fIdentityConstraintNames) {
- fIdentityConstraintNames = new RefHash2KeysTableOf<IdentityConstraint>(29, false);
+ fIdentityConstraintNames = new (fMemoryManager) RefHash2KeysTableOf<IdentityConstraint>(29, false);
}
if (fIdentityConstraintNames->containsKey(name, fTargetNSURI)) {
@@ -3821,7 +3824,7 @@ void TraverseSchema::traverseUnique(const DOMElement* const icElem,
return;
}
- IC_Unique* icUnique = new IC_Unique(name, elemDecl->getBaseName());
+ IC_Unique* icUnique = new (fMemoryManager) IC_Unique(name, elemDecl->getBaseName(), fMemoryManager);
Janitor<IC_Unique> janUnique(icUnique);
fIdentityConstraintNames->put((void*) name, fTargetNSURI, icUnique);
@@ -3895,7 +3898,7 @@ void TraverseSchema::traverseKeyRef(const DOMElement* const icElem,
return;
}
- IC_KeyRef* icKeyRef = new IC_KeyRef(name, elemDecl->getBaseName(), icKey);
+ IC_KeyRef* icKeyRef = new (fMemoryManager) IC_KeyRef(name, elemDecl->getBaseName(), icKey, fMemoryManager);
Janitor<IC_KeyRef> janKeyRef(icKeyRef);
fIdentityConstraintNames->put((void*) name, fTargetNSURI, icKeyRef);
@@ -3992,8 +3995,8 @@ bool TraverseSchema::traverseIdentityConstraint(IdentityConstraint* const ic,
// ------------------------------------------------------------------
try {
- XercesXPath* sXPath = new XercesXPath(fBuffer.getRawBuffer(), fStringPool, fNamespaceScope, fEmptyNamespaceURI, true);
- IC_Selector* icSelector = new IC_Selector(sXPath, ic);
+ XercesXPath* sXPath = new (fMemoryManager) XercesXPath(fBuffer.getRawBuffer(), fStringPool, fNamespaceScope, fEmptyNamespaceURI, true);
+ IC_Selector* icSelector = new (fMemoryManager) IC_Selector(sXPath, ic);
ic->setSelector(icSelector);
}
catch (const XPathException& e) {
@@ -4044,8 +4047,8 @@ bool TraverseSchema::traverseIdentityConstraint(IdentityConstraint* const ic,
try {
- XercesXPath* fieldXPath = new XercesXPath(fBuffer.getRawBuffer(), fStringPool, fNamespaceScope, fEmptyNamespaceURI);
- IC_Field* icField = new IC_Field(fieldXPath, ic);
+ XercesXPath* fieldXPath = new (fMemoryManager) XercesXPath(fBuffer.getRawBuffer(), fStringPool, fNamespaceScope, fEmptyNamespaceURI);
+ IC_Field* icField = new (fMemoryManager) IC_Field(fieldXPath, ic);
ic->addField(icField);
}
catch (const XPathException& e) {
@@ -4497,7 +4500,7 @@ QName* TraverseSchema::processElementDeclRef(const DOMElement* const elem,
const XMLCh* prefix = getPrefix(refName);
const XMLCh* localPart = getLocalPart(refName);
const XMLCh* uriStr = resolvePrefixToURI(elem, prefix);
- QName* eltName = new QName(prefix , localPart, uriStr != 0
+ QName* eltName = new (fMemoryManager) QName(prefix , localPart, uriStr != 0
? fURIStringPool->addOrFind(uriStr)
: fEmptyNamespaceURI);
@@ -5197,10 +5200,15 @@ TraverseSchema::createSchemaElementDecl(const DOMElement* const elem,
}
const XMLCh* prefix = getPrefix(name);
- SchemaElementDecl* elemDecl =
- new SchemaElementDecl(prefix, name, uriIndex,
- (SchemaElementDecl::ModelTypes) elemType,
- enclosingScope);
+ SchemaElementDecl* elemDecl = new (fMemoryManager) SchemaElementDecl
+ (
+ prefix
+ , name
+ , uriIndex
+ , (SchemaElementDecl::ModelTypes) elemType
+ , enclosingScope
+ , fMemoryManager
+ );
elemDecl->setFinalSet(finalSet);
elemDecl->setBlockSet(blockSet);
@@ -5352,7 +5360,7 @@ void TraverseSchema::processAttributeDeclRef(const DOMElement* const elem,
bool required = XMLString::equals(useAttr,SchemaSymbols::fgATTVAL_REQUIRED);
bool prohibited = XMLString::equals(useAttr,SchemaSymbols::fgATTVAL_PROHIBITED);
QName* attQName = refAttDef->getAttName();
- SchemaAttDef* attDef = new SchemaAttDef(attQName->getPrefix(),
+ SchemaAttDef* attDef = new (fMemoryManager) SchemaAttDef(attQName->getPrefix(),
attQName->getLocalPart(),
attQName->getURI(),
refAttValue,
@@ -5598,7 +5606,7 @@ void TraverseSchema::processComplexContent(const DOMElement* const ctElem,
int contentContext = specNode->hasAllContent() ? Group_Ref_With_All : Not_All_Context;
- specNode = new ContentSpecNode(*specNode);
+ specNode = new (fMemoryManager) ContentSpecNode(*specNode);
checkMinMax(specNode, childElem, contentContext);
}
}
@@ -5665,7 +5673,7 @@ void TraverseSchema::processComplexContent(const DOMElement* const ctElem,
if (!specNode) {
if (baseSpecNode) {
- specNode = new ContentSpecNode(*baseSpecNode);
+ specNode = new (fMemoryManager) ContentSpecNode(*baseSpecNode);
typeInfo->setContentSpec(specNode);
typeInfo->setAdoptContentSpec(true);
}
@@ -5688,8 +5696,8 @@ void TraverseSchema::processComplexContent(const DOMElement* const ctElem,
typeInfo->setAdoptContentSpec(false);
typeInfo->setContentSpec(
- new ContentSpecNode(ContentSpecNode::Sequence,
- new ContentSpecNode(*baseSpecNode),
+ new (fMemoryManager) ContentSpecNode(ContentSpecNode::Sequence,
+ new (fMemoryManager) ContentSpecNode(*baseSpecNode),
specNode));
typeInfo->setAdoptContentSpec(true);
}
@@ -5704,7 +5712,7 @@ void TraverseSchema::processComplexContent(const DOMElement* const ctElem,
// -------------------------------------------------------------
if (isBaseAnyType && typeDerivedBy == SchemaSymbols::XSD_EXTENSION) {
- ContentSpecNode* anySpecNode = new ContentSpecNode(new QName(XMLUni::fgZeroLenString,
+ ContentSpecNode* anySpecNode = new (fMemoryManager) ContentSpecNode(new (fMemoryManager) QName(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
fEmptyNamespaceURI),
false);
@@ -5720,7 +5728,7 @@ void TraverseSchema::processComplexContent(const DOMElement* const ctElem,
else {
typeInfo->setAdoptContentSpec(false);
- typeInfo->setContentSpec(new ContentSpecNode(ContentSpecNode::Sequence, anySpecNode, specNode));
+ typeInfo->setContentSpec(new (fMemoryManager) ContentSpecNode(ContentSpecNode::Sequence, anySpecNode, specNode));
typeInfo->setAdoptContentSpec(true);
if (!isMixed) {
@@ -5740,7 +5748,7 @@ void TraverseSchema::processComplexContent(const DOMElement* const ctElem,
else {
// add #PCDATA leaf and set its minOccurs to 0
ContentSpecNode* pcdataNode =
- new ContentSpecNode(new QName(XMLUni::fgZeroLenString,
+ new (fMemoryManager) ContentSpecNode(new (fMemoryManager) QName(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
XMLElementDecl::fgPCDataElemId),
false);
@@ -6019,7 +6027,7 @@ void TraverseSchema::processAttributes(const DOMElement* const elem,
if (!attGroupWildCard) {
- attGroupWildCard = new SchemaAttDef(attGroupInfo->anyAttributeAt(0));
+ attGroupWildCard = new (fMemoryManager) SchemaAttDef(attGroupInfo->anyAttributeAt(0));
for (unsigned int i= 1; i < anyAttCount; i++) {
attWildCardIntersection(attGroupWildCard, attGroupInfo->anyAttributeAt(i));
@@ -6032,7 +6040,7 @@ void TraverseSchema::processAttributes(const DOMElement* const elem,
attWildCardIntersection(completeWildCard, attGroupWildCard);
}
else {
- completeWildCard = new SchemaAttDef(attGroupWildCard);
+ completeWildCard = new (fMemoryManager) SchemaAttDef(attGroupWildCard);
janCompleteWildCard.reset(completeWildCard);
}
}
@@ -6062,7 +6070,7 @@ void TraverseSchema::processAttributes(const DOMElement* const elem,
if (isBaseAnyType) {
- baseAttWildCard = new SchemaAttDef(XMLUni::fgZeroLenString,
+ baseAttWildCard = new (fMemoryManager) SchemaAttDef(XMLUni::fgZeroLenString,
XMLUni::fgZeroLenString,
fEmptyNamespaceURI, XMLAttDef::Any_Any,
XMLAttDef::ProcessContents_Lax);
@@ -6098,7 +6106,7 @@ void TraverseSchema::processAttributes(const DOMElement* const elem,
}
else {
- SchemaAttDef* newWildCard = new SchemaAttDef(baseAttWildCard);
+ SchemaAttDef* newWildCard = new (fMemoryManager) SchemaAttDef(baseAttWildCard);
typeInfo->setAttWildCard(newWildCard);
}
}
@@ -6145,7 +6153,7 @@ void TraverseSchema::processAttributes(const DOMElement* const elem,
if (attDef.getDefaultType() != XMLAttDef::Prohibited) {
- SchemaAttDef* newAttDef = new SchemaAttDef(attName->getPrefix(),
+ SchemaAttDef* newAttDef = new (fMemoryManager) SchemaAttDef(attName->getPrefix(),
attName->getLocalPart(),
attName->getURI(),
attDef.getValue(),
@@ -6203,13 +6211,13 @@ InputSource* TraverseSchema::resolveSchemaLocation(const XMLCh* const loc) {
else {
if (fScanner->getStandardUriConformant() && urlTmp.hasInvalidChar())
ThrowXML(MalformedURLException, XMLExcepts::URL_MalformedURL);
- srcToFill = new URLInputSource(urlTmp);
+ srcToFill = new (fMemoryManager) URLInputSource(urlTmp);
}
}
catch(const MalformedURLException& e) {
// Its not a URL, so lets assume its a local file name if non-standard URI is allowed
if (!fScanner->getStandardUriConformant())
- srcToFill = new LocalFileInputSource(fSchemaInfo->getCurrentSchemaURL(),normalizedURI);
+ srcToFill = new (fMemoryManager) LocalFileInputSource(fSchemaInfo->getCurrentSchemaURL(),normalizedURI);
else
throw e;
}
@@ -6337,7 +6345,7 @@ TraverseSchema::buildValidSubstitutionListB(const DOMElement* const elem,
break;
}
- validSubsElements = new ValueVectorOf<SchemaElementDecl*>(*validSubsElements);
+ validSubsElements = new (fMemoryManager) ValueVectorOf<SchemaElementDecl*>(*validSubsElements);
fValidSubstitutionGroups->put((void*) chainElemName, chainElemURI, validSubsElements);
}
@@ -6401,7 +6409,7 @@ TraverseSchema::buildValidSubstitutionListF(const DOMElement* const elem,
return;
}
- validSubs = new ValueVectorOf<SchemaElementDecl*>(*validSubs);
+ validSubs = new (fMemoryManager) ValueVectorOf<SchemaElementDecl*>(*validSubs);
fValidSubstitutionGroups->put((void*) subsElemName, subsElemURI, validSubs);
}
@@ -6776,7 +6784,7 @@ void TraverseSchema::copyAttGroupAttributes(const DOMElement* const elem,
typeInfo->setAttWithTypeId(true);
}
- typeInfo->addAttDef(new SchemaAttDef(attDef));
+ typeInfo->addAttDef(new (fMemoryManager) SchemaAttDef(attDef));
if (toAttGroup) {
toAttGroup->addAttDef(attDef, true);
@@ -7390,7 +7398,7 @@ bool TraverseSchema::openRedefinedSchema(const DOMElement* const redefineElem) {
// Parse input source
// ------------------------------------------------------------------
if (!fParser)
- fParser = new XSDDOMParser;
+ fParser = new (fMemoryManager) XSDDOMParser;
fParser->setValidationScheme(XercesDOMParser::Val_Never);
fParser->setDoNamespaces(true);
@@ -7446,7 +7454,7 @@ bool TraverseSchema::openRedefinedSchema(const DOMElement* const redefineElem) {
// Update schema information with redefined schema
// --------------------------------------------------------
redefSchemaInfo = fSchemaInfo;
- fSchemaInfo = new SchemaInfo(0, 0, 0, fTargetNSURI, fScopeCount,
+ fSchemaInfo = new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI, fScopeCount,
fNamespaceScope->increaseDepth(),
XMLString::replicate(includeURL),
fTargetNSURIString, root);
@@ -7917,18 +7925,21 @@ void TraverseSchema::init() {
fDatatypeRegistry = fSchemaGrammar->getDatatypeRegistry();
fStringPool = fGrammarResolver->getStringPool();
fEmptyNamespaceURI = fScanner->getEmptyNamespaceId();
- fCurrentTypeNameStack = new ValueVectorOf<unsigned int>(8);
- fCurrentGroupStack = new ValueVectorOf<unsigned int>(8);
+ fCurrentTypeNameStack = new (fMemoryManager) ValueVectorOf<unsigned int>(8);
+ fCurrentGroupStack = new (fMemoryManager) ValueVectorOf<unsigned int>(8);
- fGlobalDeclarations = new ValueVectorOf<unsigned int>*[ENUM_ELT_SIZE];
+ fGlobalDeclarations = (ValueVectorOf<unsigned int>**) fMemoryManager->allocate
+ (
+ ENUM_ELT_SIZE * sizeof(ValueVectorOf<unsigned int>*)
+ );//new ValueVectorOf<unsigned int>*[ENUM_ELT_SIZE];
for(unsigned int i=0; i < ENUM_ELT_SIZE; i++)
- fGlobalDeclarations[i] = new ValueVectorOf<unsigned int>(8);
+ fGlobalDeclarations[i] = new (fMemoryManager) ValueVectorOf<unsigned int>(8);
- fNotationRegistry = new RefHash2KeysTableOf<XMLCh>(13, false);
- fSchemaInfoList = new RefHash2KeysTableOf<SchemaInfo>(29);
- fPreprocessedNodes = new RefHashTableOf<SchemaInfo>(29, false, new HashPtr());
+ fNotationRegistry = new (fMemoryManager) RefHash2KeysTableOf<XMLCh>(13, false);
+ fSchemaInfoList = new (fMemoryManager) RefHash2KeysTableOf<SchemaInfo>(29);
+ fPreprocessedNodes = new (fMemoryManager) RefHashTableOf<SchemaInfo>(29, false, new (fMemoryManager) HashPtr());
fLocator = new XSDLocator();
- fDeclStack = new ValueVectorOf<const DOMElement*>(16);
+ fDeclStack = new (fMemoryManager) ValueVectorOf<const DOMElement*>(16);
}
void TraverseSchema::cleanUp() {
@@ -7940,7 +7951,7 @@ void TraverseSchema::cleanUp() {
for(unsigned int i=0; i < ENUM_ELT_SIZE; i++)
delete fGlobalDeclarations[i];
- delete [] fGlobalDeclarations;
+ fMemoryManager->deallocate(fGlobalDeclarations);//delete [] fGlobalDeclarations;
delete fNotationRegistry;
delete fRedefineComponents;
diff --git a/src/xercesc/validators/schema/TraverseSchema.hpp b/src/xercesc/validators/schema/TraverseSchema.hpp
index 19d39f921255613209ea7a1224b6465d99ceee36..49cfd7016cfac638031f63fa3be07d22574cb8cb 100644
--- a/src/xercesc/validators/schema/TraverseSchema.hpp
+++ b/src/xercesc/validators/schema/TraverseSchema.hpp
@@ -107,7 +107,7 @@ class XSDDOMParser;
class XMLErrorReporter;
-class VALIDATORS_EXPORT TraverseSchema
+class VALIDATORS_EXPORT TraverseSchema : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -123,6 +123,7 @@ public:
, const XMLCh* const schemaURL
, XMLEntityHandler* const entityHandler
, XMLErrorReporter* const errorReporter
+ , MemoryManager* const manager
);
~TraverseSchema();
@@ -773,10 +774,11 @@ private:
RefHash2KeysTableOf<IdentityConstraint>* fIdentityConstraintNames;
RefHash2KeysTableOf<ElemVector>* fValidSubstitutionGroups;
RefHash2KeysTableOf<SchemaInfo>* fSchemaInfoList;
- GeneralAttributeCheck fAttributeCheck;
XSDDOMParser* fParser;
XSDErrorReporter fXSDErrorReporter;
XSDLocator* fLocator;
+ MemoryManager* fMemoryManager;
+ GeneralAttributeCheck fAttributeCheck;
friend class GeneralAttributeCheck;
};
diff --git a/src/xercesc/validators/schema/XSDDOMParser.cpp b/src/xercesc/validators/schema/XSDDOMParser.cpp
index e793fa48cf1b6d85677a6b9ed153a2f1e9e593d5..ced05a3a95898b8c5eb63fb84348e121d8768d25 100644
--- a/src/xercesc/validators/schema/XSDDOMParser.cpp
+++ b/src/xercesc/validators/schema/XSDDOMParser.cpp
@@ -72,8 +72,9 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XSDDOMParser: Constructors and Destructor
// ---------------------------------------------------------------------------
-XSDDOMParser::XSDDOMParser(XMLValidator* const valToAdopt) :
- XercesDOMParser(valToAdopt)
+XSDDOMParser::XSDDOMParser( XMLValidator* const valToAdopt
+ , MemoryManager* const manager) :
+ XercesDOMParser(valToAdopt, manager)
, fSawFatal(false)
, fUserErrorReporter(0)
{
diff --git a/src/xercesc/validators/schema/XSDDOMParser.hpp b/src/xercesc/validators/schema/XSDDOMParser.hpp
index c54d8e3576d9ef6122e7da9e2f7b1744187090b4..991f3435d4568aab54d885fa976c33910cfaa86a 100644
--- a/src/xercesc/validators/schema/XSDDOMParser.hpp
+++ b/src/xercesc/validators/schema/XSDDOMParser.hpp
@@ -93,7 +93,11 @@ public :
* @param valToAdopt Pointer to the validator instance to use. The
* parser is responsible for freeing the memory.
*/
- XSDDOMParser(XMLValidator* const valToAdopt = 0);
+ XSDDOMParser
+ (
+ XMLValidator* const valToAdopt = 0
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
/**
* Destructor
diff --git a/src/xercesc/validators/schema/XSDErrorReporter.hpp b/src/xercesc/validators/schema/XSDErrorReporter.hpp
index bd2dea4df1e74fcd6f8bdec75ed6534dc7927846..0554d9f87a46c827c0f6ec98afe48b9859128ecc 100644
--- a/src/xercesc/validators/schema/XSDErrorReporter.hpp
+++ b/src/xercesc/validators/schema/XSDErrorReporter.hpp
@@ -62,7 +62,7 @@
#if !defined(XSDERRORREPORTER_HPP)
#define XSDERRORREPORTER_HPP
-#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/util/XMemory.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -73,7 +73,7 @@ class XMLErrorReporter;
/**
* This class reports schema errors
*/
-class VALIDATORS_EXPORT XSDErrorReporter
+class VALIDATORS_EXPORT XSDErrorReporter : public XMemory
{
public:
// -----------------------------------------------------------------------
diff --git a/src/xercesc/validators/schema/XercesAttGroupInfo.cpp b/src/xercesc/validators/schema/XercesAttGroupInfo.cpp
index 64b05d365ecb900e93f0d4233d63235bbe3c9abf..97b12cf76527dfeb0d12726e30dc08d39e2bafcc 100644
--- a/src/xercesc/validators/schema/XercesAttGroupInfo.cpp
+++ b/src/xercesc/validators/schema/XercesAttGroupInfo.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/11/04 14:49:42 tng
* C++ Namespace Support.
*
@@ -90,11 +93,12 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XercesAttGroupInfo: Constructors and Destructor
// ---------------------------------------------------------------------------
-XercesAttGroupInfo::XercesAttGroupInfo()
+XercesAttGroupInfo::XercesAttGroupInfo(MemoryManager* const manager)
: fTypeWithId(false)
, fAttributes(0)
, fAnyAttributes(0)
, fCompleteWildCard(0)
+ , fMemoryManager(manager)
{
}
diff --git a/src/xercesc/validators/schema/XercesAttGroupInfo.hpp b/src/xercesc/validators/schema/XercesAttGroupInfo.hpp
index 0ee1ec505a4da061013d194fcd78725b204dbc82..bed00b6810b01c4cae168f89008236239e54444a 100644
--- a/src/xercesc/validators/schema/XercesAttGroupInfo.hpp
+++ b/src/xercesc/validators/schema/XercesAttGroupInfo.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -76,13 +76,13 @@
XERCES_CPP_NAMESPACE_BEGIN
-class VALIDATORS_EXPORT XercesAttGroupInfo
+class VALIDATORS_EXPORT XercesAttGroupInfo : public XMemory
{
public:
// -----------------------------------------------------------------------
// Public Constructors/Destructor
// -----------------------------------------------------------------------
- XercesAttGroupInfo();
+ XercesAttGroupInfo(MemoryManager* const manager);
~XercesAttGroupInfo();
// -----------------------------------------------------------------------
@@ -126,6 +126,7 @@ private:
RefVectorOf<SchemaAttDef>* fAttributes;
RefVectorOf<SchemaAttDef>* fAnyAttributes;
SchemaAttDef* fCompleteWildCard;
+ MemoryManager* fMemoryManager;
};
// ---------------------------------------------------------------------------
@@ -212,11 +213,11 @@ inline void XercesAttGroupInfo::addAttDef(SchemaAttDef* const toAdd,
const bool toClone) {
if (!fAttributes) {
- fAttributes = new RefVectorOf<SchemaAttDef>(4);
+ fAttributes = new (fMemoryManager) RefVectorOf<SchemaAttDef>(4);
}
if (toClone) {
- fAttributes->addElement(new SchemaAttDef(toAdd));
+ fAttributes->addElement(new (fMemoryManager) SchemaAttDef(toAdd));
}
else {
fAttributes->addElement(toAdd);
@@ -227,11 +228,11 @@ inline void XercesAttGroupInfo::addAnyAttDef(SchemaAttDef* const toAdd,
const bool toClone) {
if (!fAnyAttributes) {
- fAnyAttributes = new RefVectorOf<SchemaAttDef>(2);
+ fAnyAttributes = new (fMemoryManager) RefVectorOf<SchemaAttDef>(2);
}
if (toClone) {
- fAnyAttributes->addElement(new SchemaAttDef(toAdd));
+ fAnyAttributes->addElement(new (fMemoryManager) SchemaAttDef(toAdd));
}
else {
fAnyAttributes->addElement(toAdd);
diff --git a/src/xercesc/validators/schema/XercesGroupInfo.cpp b/src/xercesc/validators/schema/XercesGroupInfo.cpp
index 796383d7f06031a294b64d28c657e25483672d14..db512c5cb90b67091a7c3d5696c0b40d18ac9a12 100644
--- a/src/xercesc/validators/schema/XercesGroupInfo.cpp
+++ b/src/xercesc/validators/schema/XercesGroupInfo.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:57:27 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2002/11/04 14:49:42 tng
* C++ Namespace Support.
*
@@ -88,7 +91,7 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XercesGroupInfo: Constructors and Destructor
// ---------------------------------------------------------------------------
-XercesGroupInfo::XercesGroupInfo()
+XercesGroupInfo::XercesGroupInfo(MemoryManager* const manager)
: fCheckElementConsistency(true)
, fScope(-1)
, fContentSpec(0)
@@ -96,7 +99,7 @@ XercesGroupInfo::XercesGroupInfo()
, fBaseGroup(0)
, fLocator(0)
{
- fElements = new RefVectorOf<SchemaElementDecl>(4, false);
+ fElements = new (manager) RefVectorOf<SchemaElementDecl>(4, false);
}
diff --git a/src/xercesc/validators/schema/XercesGroupInfo.hpp b/src/xercesc/validators/schema/XercesGroupInfo.hpp
index bc499929d0b3d8525504a86e8b807afa276d66d0..d17e242da32fc26a763bebf4f93ba251f9747df5 100644
--- a/src/xercesc/validators/schema/XercesGroupInfo.hpp
+++ b/src/xercesc/validators/schema/XercesGroupInfo.hpp
@@ -83,13 +83,13 @@ class ContentSpecNode;
class XSDLocator;
-class VALIDATORS_EXPORT XercesGroupInfo
+class VALIDATORS_EXPORT XercesGroupInfo : public XMemory
{
public:
// -----------------------------------------------------------------------
// Public Constructors/Destructor
// -----------------------------------------------------------------------
- XercesGroupInfo();
+ XercesGroupInfo(MemoryManager* const manager);
~XercesGroupInfo();
// -----------------------------------------------------------------------
diff --git a/src/xercesc/validators/schema/identity/FieldActivator.cpp b/src/xercesc/validators/schema/identity/FieldActivator.cpp
index 9fc0fa301901082d2e0a95204209a2bc78b811e5..96940197e224cef232e64054fb3d2b7a7c66f6b3 100644
--- a/src/xercesc/validators/schema/identity/FieldActivator.cpp
+++ b/src/xercesc/validators/schema/identity/FieldActivator.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/11/04 14:47:41 tng
* C++ Namespace Support.
*
@@ -84,15 +87,18 @@ XERCES_CPP_NAMESPACE_BEGIN
// FieldActivator: Constructors and Destructor
// ---------------------------------------------------------------------------
FieldActivator::FieldActivator(ValueStoreCache* const valueStoreCache,
- XPathMatcherStack* const matcherStack)
+ XPathMatcherStack* const matcherStack,
+ MemoryManager* const manager)
: fValueStoreCache(valueStoreCache)
, fMatcherStack(matcherStack)
+ , fMemoryManager(manager)
{
}
FieldActivator::FieldActivator(const FieldActivator& other)
: fValueStoreCache(other.fValueStoreCache)
, fMatcherStack(other.fMatcherStack)
+ , fMemoryManager(XMLPlatformUtils::fgMemoryManager)
{
}
@@ -121,7 +127,7 @@ FieldActivator& FieldActivator::operator =(const FieldActivator& other) {
XPathMatcher* FieldActivator::activateField(IC_Field* const field, const int initialDepth) {
ValueStore* valueStore = fValueStoreCache->getValueStoreFor(field, initialDepth);
- XPathMatcher* matcher = field->createMatcher(valueStore);
+ XPathMatcher* matcher = field->createMatcher(valueStore, fMemoryManager);
field->setMayMatch(true);
fMatcherStack->addMatcher(matcher);
diff --git a/src/xercesc/validators/schema/identity/FieldActivator.hpp b/src/xercesc/validators/schema/identity/FieldActivator.hpp
index 79ba13fc87413e0e638ebf416ea4c9ec47759e52..49f5444ffb3d891e3836f5db5cb068626a7ec312 100644
--- a/src/xercesc/validators/schema/identity/FieldActivator.hpp
+++ b/src/xercesc/validators/schema/identity/FieldActivator.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -69,7 +69,7 @@
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
-#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/util/XMemory.hpp>
XERCES_CPP_NAMESPACE_BEGIN
@@ -83,14 +83,15 @@ class IC_Field;
class XPathMatcherStack;
-class VALIDATORS_EXPORT FieldActivator
+class VALIDATORS_EXPORT FieldActivator : public XMemory
{
public:
// -----------------------------------------------------------------------
// Constructors/Destructor
// -----------------------------------------------------------------------
FieldActivator(ValueStoreCache* const valueStoreCache,
- XPathMatcherStack* const matcherStack);
+ XPathMatcherStack* const matcherStack,
+ MemoryManager* const manager);
FieldActivator(const FieldActivator& other);
~FieldActivator();
@@ -132,6 +133,7 @@ private:
// -----------------------------------------------------------------------
ValueStoreCache* fValueStoreCache;
XPathMatcherStack* fMatcherStack;
+ MemoryManager* fMemoryManager;
};
diff --git a/src/xercesc/validators/schema/identity/FieldValueMap.cpp b/src/xercesc/validators/schema/identity/FieldValueMap.cpp
index 2b99c9cf7618b382be2be2d4b57d7f85ba4e6411..79410c5dc4c887a38c35ff3e6dc30d4356e0d275 100644
--- a/src/xercesc/validators/schema/identity/FieldValueMap.cpp
+++ b/src/xercesc/validators/schema/identity/FieldValueMap.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/12/18 14:17:59 gareth
* Fix to bug #13438. When you eant a vector that calls delete[] on its members you should use RefArrayVectorOf.
*
@@ -80,10 +83,11 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// FieldValueMap: Constructors and Destructor
// ---------------------------------------------------------------------------
-FieldValueMap::FieldValueMap()
+FieldValueMap::FieldValueMap(MemoryManager* const manager)
: fFields(0)
, fValidators(0)
, fValues(0)
+ , fMemoryManager(manager)
{
}
@@ -91,15 +95,16 @@ FieldValueMap::FieldValueMap(const FieldValueMap& other)
: fFields(0)
, fValidators(0)
, fValues(0)
+ , fMemoryManager(XMLPlatformUtils::fgMemoryManager)
{
try {
if (other.fFields) {
unsigned int valuesSize = other.fValues->size();
- fFields = new ValueVectorOf<IC_Field*>(*(other.fFields));
- fValidators = new ValueVectorOf<DatatypeValidator*>(*(other.fValidators));
- fValues = new RefArrayVectorOf<XMLCh>(other.fFields->curCapacity());
+ fFields = new (fMemoryManager) ValueVectorOf<IC_Field*>(*(other.fFields));
+ fValidators = new (fMemoryManager) ValueVectorOf<DatatypeValidator*>(*(other.fValidators));
+ fValues = new (fMemoryManager) RefArrayVectorOf<XMLCh>(other.fFields->curCapacity());
for (unsigned int i=0; i<valuesSize; i++) {
fValues->addElement(XMLString::replicate(other.fValues->elementAt(i)));
diff --git a/src/xercesc/validators/schema/identity/FieldValueMap.hpp b/src/xercesc/validators/schema/identity/FieldValueMap.hpp
index 0ee9fd1f5be959b82f7a8868cfff6f306cb069d6..12f1c54bcf493910b17b9e331fa5593daea7c99a 100644
--- a/src/xercesc/validators/schema/identity/FieldValueMap.hpp
+++ b/src/xercesc/validators/schema/identity/FieldValueMap.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -82,13 +82,13 @@ class IC_Field;
class DatatypeValidator;
-class VALIDATORS_EXPORT FieldValueMap
+class VALIDATORS_EXPORT FieldValueMap : public XMemory
{
public:
// -----------------------------------------------------------------------
// Constructors/Destructor
// -----------------------------------------------------------------------
- FieldValueMap();
+ FieldValueMap(MemoryManager* const manager);
FieldValueMap(const FieldValueMap& other);
~FieldValueMap();
@@ -125,6 +125,7 @@ private:
ValueVectorOf<IC_Field*>* fFields;
ValueVectorOf<DatatypeValidator*>* fValidators;
RefArrayVectorOf<XMLCh>* fValues;
+ MemoryManager* fMemoryManager;
};
@@ -198,9 +199,9 @@ inline void FieldValueMap::put(IC_Field* const key,
const XMLCh* const value) {
if (!fFields) {
- fFields = new ValueVectorOf<IC_Field*>(4);
- fValidators = new ValueVectorOf<DatatypeValidator*>(4);
- fValues = new RefArrayVectorOf<XMLCh>(4);
+ fFields = new (fMemoryManager) ValueVectorOf<IC_Field*>(4);
+ fValidators = new (fMemoryManager) ValueVectorOf<DatatypeValidator*>(4);
+ fValues = new (fMemoryManager) RefArrayVectorOf<XMLCh>(4);
}
int keyIndex = indexOf(key);
diff --git a/src/xercesc/validators/schema/identity/IC_Field.cpp b/src/xercesc/validators/schema/identity/IC_Field.cpp
index 813fe5f72d1a3bb52c02f6b158a6eeac3c0e4ed4..145c02dfbaad59203e8f42fb6f5f416914d840fc 100644
--- a/src/xercesc/validators/schema/identity/IC_Field.cpp
+++ b/src/xercesc/validators/schema/identity/IC_Field.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2003/01/13 16:30:19 knoaman
* [Bug 14469] Validator doesn't enforce xsd:key.
*
@@ -85,9 +88,11 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// FieldMatcher: Constructors and Destructor
// ---------------------------------------------------------------------------
-FieldMatcher::FieldMatcher(XercesXPath* const xpath, IC_Field* const aField,
- ValueStore* const valueStore)
- : XPathMatcher(xpath, 0)
+FieldMatcher::FieldMatcher(XercesXPath* const xpath,
+ IC_Field* const aField,
+ ValueStore* const valueStore,
+ MemoryManager* const manager)
+ : XPathMatcher(xpath, (IdentityConstraint*) 0, manager)
, fField(aField)
, fValueStore(valueStore)
{
@@ -144,9 +149,10 @@ bool IC_Field::operator!= (const IC_Field& other) const {
// ---------------------------------------------------------------------------
// IC_Field: Factory methods
// ---------------------------------------------------------------------------
-XPathMatcher* IC_Field::createMatcher(ValueStore* const valueStore) {
+XPathMatcher* IC_Field::createMatcher(ValueStore* const valueStore,
+ MemoryManager* const manager) {
- return new FieldMatcher(fXPath, this, valueStore);
+ return new (manager) FieldMatcher(fXPath, this, valueStore, manager);
}
XERCES_CPP_NAMESPACE_END
diff --git a/src/xercesc/validators/schema/identity/IC_Field.hpp b/src/xercesc/validators/schema/identity/IC_Field.hpp
index 1a60b59c4a8fc12d2b796622fc590e36ec480e0f..79f804c5e529a60fd7b1f292526d9d58a23ddbf3 100644
--- a/src/xercesc/validators/schema/identity/IC_Field.hpp
+++ b/src/xercesc/validators/schema/identity/IC_Field.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -75,7 +75,7 @@ XERCES_CPP_NAMESPACE_BEGIN
class ValueStore;
-class VALIDATORS_EXPORT IC_Field
+class VALIDATORS_EXPORT IC_Field : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -106,7 +106,8 @@ public:
// -----------------------------------------------------------------------
// Factory methods
// -----------------------------------------------------------------------
- XPathMatcher* createMatcher(ValueStore* const valueStore);
+ XPathMatcher* createMatcher(ValueStore* const valueStore,
+ MemoryManager* const manager);
private:
// -----------------------------------------------------------------------
@@ -148,8 +149,10 @@ private:
// -----------------------------------------------------------------------
// Constructors/Destructor
// -----------------------------------------------------------------------
- FieldMatcher(XercesXPath* const anXPath, IC_Field* const aField,
- ValueStore* const valueStore);
+ FieldMatcher(XercesXPath* const anXPath,
+ IC_Field* const aField,
+ ValueStore* const valueStore,
+ MemoryManager* const manager);
// -----------------------------------------------------------------------
// Unimplemented contstructors and operators
diff --git a/src/xercesc/validators/schema/identity/IC_Key.cpp b/src/xercesc/validators/schema/identity/IC_Key.cpp
index fe0702bda1cc202f105a015dffca918f96a6ac0d..088451bae6f34c4fe12775c98929489ee4e260e6 100644
--- a/src/xercesc/validators/schema/identity/IC_Key.cpp
+++ b/src/xercesc/validators/schema/identity/IC_Key.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:47:41 tng
* C++ Namespace Support.
*
@@ -78,8 +81,9 @@ XERCES_CPP_NAMESPACE_BEGIN
// IC_Key: Constructors and Destructor
// ---------------------------------------------------------------------------
IC_Key::IC_Key(const XMLCh* const identityConstraintName,
- const XMLCh* const elemName)
- : IdentityConstraint(identityConstraintName, elemName)
+ const XMLCh* const elemName,
+ MemoryManager* const manager)
+ : IdentityConstraint(identityConstraintName, elemName, manager)
{
}
diff --git a/src/xercesc/validators/schema/identity/IC_Key.hpp b/src/xercesc/validators/schema/identity/IC_Key.hpp
index 20f5824453e3efcab7a7805eb0b956d71fabedcb..d07cc70769db94aec54a33fad3eecc1affd69bd9 100644
--- a/src/xercesc/validators/schema/identity/IC_Key.hpp
+++ b/src/xercesc/validators/schema/identity/IC_Key.hpp
@@ -76,7 +76,8 @@ public:
// Constructors/Destructor
// -----------------------------------------------------------------------
IC_Key(const XMLCh* const identityConstraintName,
- const XMLCh* const elemName);
+ const XMLCh* const elemName,
+ MemoryManager* const manager);
~IC_Key();
// -----------------------------------------------------------------------
diff --git a/src/xercesc/validators/schema/identity/IC_KeyRef.cpp b/src/xercesc/validators/schema/identity/IC_KeyRef.cpp
index 89b4b77dd19e6eeb69d4cd549a395351d8ede4db..129aab7f4abba726192a238ba9bb1caaa2dae942 100644
--- a/src/xercesc/validators/schema/identity/IC_KeyRef.cpp
+++ b/src/xercesc/validators/schema/identity/IC_KeyRef.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:47:41 tng
* C++ Namespace Support.
*
@@ -79,8 +82,9 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
IC_KeyRef::IC_KeyRef(const XMLCh* const identityConstraintName,
const XMLCh* const elemName,
- IdentityConstraint* const icKey)
- : IdentityConstraint(identityConstraintName, elemName)
+ IdentityConstraint* const icKey,
+ MemoryManager* const manager)
+ : IdentityConstraint(identityConstraintName, elemName, manager)
, fKey(icKey)
{
}
diff --git a/src/xercesc/validators/schema/identity/IC_KeyRef.hpp b/src/xercesc/validators/schema/identity/IC_KeyRef.hpp
index f17d6ddeb239f3f52c937b3fb20ffdd800c40705..2814af953f1428c1a341b69826262fe0d098a6b8 100644
--- a/src/xercesc/validators/schema/identity/IC_KeyRef.hpp
+++ b/src/xercesc/validators/schema/identity/IC_KeyRef.hpp
@@ -77,7 +77,8 @@ public:
// -----------------------------------------------------------------------
IC_KeyRef(const XMLCh* const identityConstraintName,
const XMLCh* const elemName,
- IdentityConstraint* const icKey);
+ IdentityConstraint* const icKey,
+ MemoryManager* const manager);
~IC_KeyRef();
// -----------------------------------------------------------------------
diff --git a/src/xercesc/validators/schema/identity/IC_Selector.cpp b/src/xercesc/validators/schema/identity/IC_Selector.cpp
index 25954f93a726ddb0cd2cd8279184d9d0c8f58d57..fb8d281aca30ddcc87b8242b319ab10ccedfb278 100644
--- a/src/xercesc/validators/schema/identity/IC_Selector.cpp
+++ b/src/xercesc/validators/schema/identity/IC_Selector.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.5 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.4 2003/01/13 16:30:19 knoaman
* [Bug 14469] Validator doesn't enforce xsd:key.
*
@@ -96,8 +99,9 @@ XERCES_CPP_NAMESPACE_BEGIN
SelectorMatcher::SelectorMatcher(XercesXPath* const xpath,
IC_Selector* const selector,
FieldActivator* const fieldActivator,
- const int initialDepth)
- : XPathMatcher(xpath, selector->getIdentityConstraint())
+ const int initialDepth,
+ MemoryManager* const manager)
+ : XPathMatcher(xpath, selector->getIdentityConstraint(), manager)
, fInitialDepth(initialDepth)
, fElementDepth(0)
, fMatchedDepth(-1)
@@ -188,9 +192,11 @@ bool IC_Selector::operator !=(const IC_Selector& other) const {
// ---------------------------------------------------------------------------
// IC_Selector: Factory methods
// ---------------------------------------------------------------------------
-XPathMatcher* IC_Selector::createMatcher(FieldActivator* const fieldActivator, const int initialDepth) {
+XPathMatcher* IC_Selector::createMatcher(FieldActivator* const fieldActivator,
+ const int initialDepth,
+ MemoryManager* const manager) {
- return new SelectorMatcher(fXPath, this, fieldActivator, initialDepth);
+ return new (manager) SelectorMatcher(fXPath, this, fieldActivator, initialDepth, manager);
}
XERCES_CPP_NAMESPACE_END
diff --git a/src/xercesc/validators/schema/identity/IC_Selector.hpp b/src/xercesc/validators/schema/identity/IC_Selector.hpp
index 395277a839e4dbea59e0c0d86ee82818648f3910..8a3b28c3c6e6324af8752e037549343c5e8c75d1 100644
--- a/src/xercesc/validators/schema/identity/IC_Selector.hpp
+++ b/src/xercesc/validators/schema/identity/IC_Selector.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -75,7 +75,7 @@ XERCES_CPP_NAMESPACE_BEGIN
class FieldActivator;
-class VALIDATORS_EXPORT IC_Selector
+class VALIDATORS_EXPORT IC_Selector : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -100,7 +100,9 @@ public:
// -----------------------------------------------------------------------
// Factory methods
// -----------------------------------------------------------------------
- XPathMatcher* createMatcher(FieldActivator* const fieldActivator, const int initialDepth);
+ XPathMatcher* createMatcher(FieldActivator* const fieldActivator,
+ const int initialDepth,
+ MemoryManager* const manager);
private:
// -----------------------------------------------------------------------
@@ -143,8 +145,11 @@ private:
// -----------------------------------------------------------------------
// Constructors/Destructor
// -----------------------------------------------------------------------
- SelectorMatcher(XercesXPath* const anXPath, IC_Selector* const selector,
- FieldActivator* const fieldActivator, const int initialDepth);
+ SelectorMatcher(XercesXPath* const anXPath,
+ IC_Selector* const selector,
+ FieldActivator* const fieldActivator,
+ const int initialDepth,
+ MemoryManager* const manager);
// -----------------------------------------------------------------------
// Unimplemented contstructors and operators
diff --git a/src/xercesc/validators/schema/identity/IC_Unique.cpp b/src/xercesc/validators/schema/identity/IC_Unique.cpp
index e95c2cd97bfaf78f19aff99c1d1ac1889feb5186..6fecd2cf19b4bdf148fb3fcc5796136dc5ee9c30 100644
--- a/src/xercesc/validators/schema/identity/IC_Unique.cpp
+++ b/src/xercesc/validators/schema/identity/IC_Unique.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:47:41 tng
* C++ Namespace Support.
*
@@ -78,8 +81,9 @@ XERCES_CPP_NAMESPACE_BEGIN
// IC_Unique: Constructors and Destructor
// ---------------------------------------------------------------------------
IC_Unique::IC_Unique(const XMLCh* const identityConstraintName,
- const XMLCh* const elemName)
- : IdentityConstraint(identityConstraintName, elemName)
+ const XMLCh* const elemName,
+ MemoryManager* const manager)
+ : IdentityConstraint(identityConstraintName, elemName, manager)
{
}
diff --git a/src/xercesc/validators/schema/identity/IC_Unique.hpp b/src/xercesc/validators/schema/identity/IC_Unique.hpp
index f47cc4aa61ac700c2a28bf4dbd14d057a7e40150..91dbc51e9e31a6338e4d3435b2fd09926b1e2b49 100644
--- a/src/xercesc/validators/schema/identity/IC_Unique.hpp
+++ b/src/xercesc/validators/schema/identity/IC_Unique.hpp
@@ -80,7 +80,8 @@ public:
// Constructors/Destructor
// -----------------------------------------------------------------------
IC_Unique(const XMLCh* const identityConstraintName,
- const XMLCh* const elemName);
+ const XMLCh* const elemName,
+ MemoryManager* const manager);
~IC_Unique();
// -----------------------------------------------------------------------
diff --git a/src/xercesc/validators/schema/identity/IdentityConstraint.cpp b/src/xercesc/validators/schema/identity/IdentityConstraint.cpp
index 519b4908dcd65bfa2de30e09c84d1b820a9b5cf9..53bab02e1980a1894a5f38e020a14392dd5d407a 100644
--- a/src/xercesc/validators/schema/identity/IdentityConstraint.cpp
+++ b/src/xercesc/validators/schema/identity/IdentityConstraint.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.3 2002/11/04 14:47:41 tng
* C++ Namespace Support.
*
@@ -87,14 +90,17 @@ XERCES_CPP_NAMESPACE_BEGIN
// IdentityConstraint: Constructors and Destructor
// ---------------------------------------------------------------------------
IdentityConstraint::IdentityConstraint(const XMLCh* const identityConstraintName,
- const XMLCh* const elemName)
- : fIdentityConstraintName(XMLString::replicate(identityConstraintName))
+ const XMLCh* const elemName,
+ MemoryManager* const manager)
+ : fIdentityConstraintName(0)
, fElemName(0)
, fSelector(0)
, fFields(0)
+ , fMemoryManager(manager)
{
try {
- fElemName = XMLString::replicate(elemName);
+ fIdentityConstraintName = XMLString::replicate(identityConstraintName, fMemoryManager);
+ fElemName = XMLString::replicate(elemName, fMemoryManager);
}
catch(...) {
@@ -159,8 +165,8 @@ void IdentityConstraint::setSelector(IC_Selector* const selector) {
// ---------------------------------------------------------------------------
void IdentityConstraint::cleanUp() {
- delete [] fIdentityConstraintName;
- delete [] fElemName;
+ fMemoryManager->deallocate(fIdentityConstraintName);//delete [] fIdentityConstraintName;
+ fMemoryManager->deallocate(fElemName);//delete [] fElemName;
delete fFields;
delete fSelector;
}
diff --git a/src/xercesc/validators/schema/identity/IdentityConstraint.hpp b/src/xercesc/validators/schema/identity/IdentityConstraint.hpp
index eb2c7127ded4d20c2c6ce4bb97bf3e721facd589..552c1ac825e0ffaa5f8f806d7015b253a1366143 100644
--- a/src/xercesc/validators/schema/identity/IdentityConstraint.hpp
+++ b/src/xercesc/validators/schema/identity/IdentityConstraint.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -79,7 +79,7 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
class IC_Selector;
-class VALIDATORS_EXPORT IdentityConstraint
+class VALIDATORS_EXPORT IdentityConstraint : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -128,7 +128,8 @@ protected:
// Constructors/Destructor
// -----------------------------------------------------------------------
IdentityConstraint(const XMLCh* const identityConstraintName,
- const XMLCh* const elementName);
+ const XMLCh* const elementName,
+ MemoryManager* const manager);
private:
// -----------------------------------------------------------------------
@@ -161,6 +162,7 @@ private:
XMLCh* fElemName;
IC_Selector* fSelector;
RefVectorOf<IC_Field>* fFields;
+ MemoryManager* fMemoryManager;
};
@@ -197,7 +199,7 @@ inline IC_Selector* IdentityConstraint::getSelector() const {
inline void IdentityConstraint::addField(IC_Field* const field) {
if (!fFields) {
- fFields = new RefVectorOf<IC_Field>(4);
+ fFields = new (fMemoryManager) RefVectorOf<IC_Field>(4);
}
fFields->addElement(field);
diff --git a/src/xercesc/validators/schema/identity/ValueStore.cpp b/src/xercesc/validators/schema/identity/ValueStore.cpp
index 6e37e8fef24e7b02a634608c4e8bd586018c988e..85285e2a6fef6b065b3e712891fa5ed81008f713 100644
--- a/src/xercesc/validators/schema/identity/ValueStore.cpp
+++ b/src/xercesc/validators/schema/identity/ValueStore.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/12/04 02:32:43 knoaman
* #include cleanup.
*
@@ -99,13 +102,16 @@ XERCES_CPP_NAMESPACE_BEGIN
// ValueStore: Constructors and Destructor
// ---------------------------------------------------------------------------
ValueStore::ValueStore(IdentityConstraint* const ic,
- XMLScanner* const scanner)
+ XMLScanner* const scanner,
+ MemoryManager* const manager)
: fDoReportError(false)
, fValuesCount(0)
, fIdentityConstraint(ic)
+ , fValues(manager)
, fValueTuples(0)
, fKeyValueStore(0)
, fScanner(scanner)
+ , fMemoryManager(manager)
{
fDoReportError = (scanner && scanner->getDoValidation());
}
@@ -156,10 +162,10 @@ void ValueStore::addValue(IC_Field* const field,
// store values
if (!fValueTuples) {
- fValueTuples = new RefVectorOf<FieldValueMap>(4);
+ fValueTuples = new (fMemoryManager) RefVectorOf<FieldValueMap>(4);
}
- fValueTuples->addElement(new FieldValueMap(fValues));
+ fValueTuples->addElement(new (fMemoryManager) FieldValueMap(fValues));
}
}
@@ -178,10 +184,10 @@ void ValueStore::append(const ValueStore* const other) {
if (!contains(valueMap)) {
if (!fValueTuples) {
- fValueTuples = new RefVectorOf<FieldValueMap>(4);
+ fValueTuples = new (fMemoryManager) RefVectorOf<FieldValueMap>(4);
}
- fValueTuples->addElement(new FieldValueMap(*valueMap));
+ fValueTuples->addElement(new (fMemoryManager) FieldValueMap(*valueMap));
}
}
}
diff --git a/src/xercesc/validators/schema/identity/ValueStore.hpp b/src/xercesc/validators/schema/identity/ValueStore.hpp
index 4f533339ccba9a2ab68b858f4c2cbf34dfbbf270..b10007b062a4987fd2ffc121e3b8c55c1aac51e5 100644
--- a/src/xercesc/validators/schema/identity/ValueStore.hpp
+++ b/src/xercesc/validators/schema/identity/ValueStore.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -83,13 +83,15 @@ class XMLScanner;
class ValueStoreCache;
-class VALIDATORS_EXPORT ValueStore
+class VALIDATORS_EXPORT ValueStore : public XMemory
{
public:
// -----------------------------------------------------------------------
// Constructors/Destructor
// -----------------------------------------------------------------------
- ValueStore(IdentityConstraint* const ic, XMLScanner* const scanner);
+ ValueStore(IdentityConstraint* const ic,
+ XMLScanner* const scanner,
+ MemoryManager* const manager);
~ValueStore();
// -----------------------------------------------------------------------
@@ -150,6 +152,7 @@ private:
RefVectorOf<FieldValueMap>* fValueTuples;
ValueStore* fKeyValueStore;
XMLScanner* fScanner; // for error reporting - REVISIT
+ MemoryManager* fMemoryManager;
};
// ---------------------------------------------------------------------------
diff --git a/src/xercesc/validators/schema/identity/ValueStoreCache.cpp b/src/xercesc/validators/schema/identity/ValueStoreCache.cpp
index 2047ab9d1f10966cb965e453762b831e50643b9e..ef8556bf467467bc2d36497723be9d63a836fa50 100644
--- a/src/xercesc/validators/schema/identity/ValueStoreCache.cpp
+++ b/src/xercesc/validators/schema/identity/ValueStoreCache.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/11/04 14:47:41 tng
* C++ Namespace Support.
*
@@ -89,11 +92,13 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// ValueStoreCache: Constructors and Destructor
// ---------------------------------------------------------------------------
-ValueStoreCache::ValueStoreCache()
+ValueStoreCache::ValueStoreCache(MemoryManager* const manager)
: fValueStores(0)
, fGlobalICMap(0)
, fIC2ValueStoreMap(0)
, fGlobalMapStack(0)
+ , fScanner(0)
+ , fMemoryManager(manager)
{
try {
init();
@@ -124,7 +129,7 @@ void ValueStoreCache::startDocument() {
void ValueStoreCache::startElement() {
fGlobalMapStack->push(fGlobalICMap);
- fGlobalICMap = new RefHashTableOf<ValueStore>(13, false, new HashPtr());
+ fGlobalICMap = new (fMemoryManager) RefHashTableOf<ValueStore>(13, false, new (fMemoryManager) HashPtr());
}
void ValueStoreCache::endElement() {
@@ -166,10 +171,10 @@ void ValueStoreCache::cleanUp() {
void ValueStoreCache::init() {
- fValueStores = new RefVectorOf<ValueStore>(8);
- fGlobalICMap = new RefHashTableOf<ValueStore>(13, false, new HashPtr());
- fIC2ValueStoreMap = new RefHash2KeysTableOf<ValueStore>(13, false, new HashPtr());
- fGlobalMapStack = new RefStackOf<RefHashTableOf<ValueStore> >(8);
+ fValueStores = new (fMemoryManager) RefVectorOf<ValueStore>(8);
+ fGlobalICMap = new (fMemoryManager) RefHashTableOf<ValueStore>(13, false, new (fMemoryManager) HashPtr());
+ fIC2ValueStoreMap = new (fMemoryManager) RefHash2KeysTableOf<ValueStore>(13, false, new (fMemoryManager) HashPtr());
+ fGlobalMapStack = new (fMemoryManager) RefStackOf<RefHashTableOf<ValueStore> >(8);
}
void ValueStoreCache::initValueStoresFor(SchemaElementDecl* const elemDecl,
@@ -181,7 +186,7 @@ void ValueStoreCache::initValueStoresFor(SchemaElementDecl* const elemDecl,
for (unsigned int i=0; i<icCount; i++) {
IdentityConstraint* ic = elemDecl->getIdentityConstraintAt(i);
- ValueStore* valueStore = valueStore = new ValueStore(ic, fScanner);
+ ValueStore* valueStore = valueStore = new (fMemoryManager) ValueStore(ic, fScanner, fMemoryManager);
fValueStores->addElement(valueStore);
fIC2ValueStoreMap->put(ic, initialDepth, valueStore);
}
@@ -199,7 +204,7 @@ void ValueStoreCache::transplant(IdentityConstraint* const ic, const int initial
if (currVals) {
currVals->append(newVals);
} else {
- ValueStore* valueStore = new ValueStore(ic, fScanner);
+ ValueStore* valueStore = new (fMemoryManager) ValueStore(ic, fScanner, fMemoryManager);
fValueStores->addElement(valueStore);
valueStore->append(newVals);
fGlobalICMap->put(ic, valueStore);
diff --git a/src/xercesc/validators/schema/identity/ValueStoreCache.hpp b/src/xercesc/validators/schema/identity/ValueStoreCache.hpp
index c4143192a368802bec3f6f6900aefb7eac21cd19..d2b758f8fdc12c4ceba579b34363dc09cc11a876 100644
--- a/src/xercesc/validators/schema/identity/ValueStoreCache.hpp
+++ b/src/xercesc/validators/schema/identity/ValueStoreCache.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -99,13 +99,13 @@ class SchemaElementDecl;
class XMLScanner;
-class VALIDATORS_EXPORT ValueStoreCache
+class VALIDATORS_EXPORT ValueStoreCache : public XMemory
{
public:
// -----------------------------------------------------------------------
// Constructors/Destructor
// -----------------------------------------------------------------------
- ValueStoreCache();
+ ValueStoreCache(MemoryManager* const manager);
~ValueStoreCache();
// -----------------------------------------------------------------------
@@ -164,6 +164,7 @@ private:
RefHash2KeysTableOf<ValueStore>* fIC2ValueStoreMap;
RefStackOf<RefHashTableOf<ValueStore> >* fGlobalMapStack;
XMLScanner* fScanner;
+ MemoryManager* fMemoryManager;
};
// ---------------------------------------------------------------------------
diff --git a/src/xercesc/validators/schema/identity/XPathMatcher.cpp b/src/xercesc/validators/schema/identity/XPathMatcher.cpp
index 5c06307b07c68f1106f82fb2c6f77a907d83748c..6d7ef9bcf2644f3d50bd4eedf61d954a54273345 100644
--- a/src/xercesc/validators/schema/identity/XPathMatcher.cpp
+++ b/src/xercesc/validators/schema/identity/XPathMatcher.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.6 2003/01/13 20:16:52 knoaman
* [Bug 16024] SchemaSymbols.hpp conflicts C++ Builder 6 dir.h
*
@@ -97,7 +100,8 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XPathMatcher: Constructors and Destructor
// ---------------------------------------------------------------------------
-XPathMatcher::XPathMatcher(XercesXPath* const xpath)
+XPathMatcher::XPathMatcher( XercesXPath* const xpath
+ , MemoryManager* const manager)
: fLocationPathSize(0)
, fMatched(0)
, fNoMatchDepth(0)
@@ -105,6 +109,7 @@ XPathMatcher::XPathMatcher(XercesXPath* const xpath)
, fStepIndexes(0)
, fLocationPaths(0)
, fIdentityConstraint(0)
+ , fMemoryManager(manager)
{
try {
init(xpath);
@@ -118,7 +123,8 @@ XPathMatcher::XPathMatcher(XercesXPath* const xpath)
XPathMatcher::XPathMatcher(XercesXPath* const xpath,
- IdentityConstraint* const ic)
+ IdentityConstraint* const ic,
+ MemoryManager* const manager)
: fLocationPathSize(0)
, fMatched(0)
, fNoMatchDepth(0)
@@ -126,6 +132,7 @@ XPathMatcher::XPathMatcher(XercesXPath* const xpath,
, fStepIndexes(0)
, fLocationPaths(0)
, fIdentityConstraint(ic)
+ , fMemoryManager(manager)
{
try {
init(xpath);
@@ -155,13 +162,22 @@ void XPathMatcher::init(XercesXPath* const xpath) {
if (fLocationPathSize) {
- fStepIndexes = new RefVectorOf<ValueStackOf<int> >(fLocationPathSize);
- fCurrentStep = new int[fLocationPathSize];
- fNoMatchDepth = new int[fLocationPathSize];
- fMatched = new int[fLocationPathSize];
+ fStepIndexes = new (fMemoryManager) RefVectorOf<ValueStackOf<int> >(fLocationPathSize);
+ fCurrentStep = (int*) fMemoryManager->allocate
+ (
+ fLocationPathSize * sizeof(int)
+ );//new int[fLocationPathSize];
+ fNoMatchDepth = (int*) fMemoryManager->allocate
+ (
+ fLocationPathSize * sizeof(int)
+ );//new int[fLocationPathSize];
+ fMatched = (int*) fMemoryManager->allocate
+ (
+ fLocationPathSize * sizeof(int)
+ );//new int[fLocationPathSize];
for(unsigned int i=0; i < fLocationPathSize; i++) {
- fStepIndexes->addElement(new ValueStackOf<int>(8));
+ fStepIndexes->addElement(new (fMemoryManager) ValueStackOf<int>(8));
}
}
}
diff --git a/src/xercesc/validators/schema/identity/XPathMatcher.hpp b/src/xercesc/validators/schema/identity/XPathMatcher.hpp
index db7cae23468b4a9276b11bc172c20d9f2a95610e..d34ddd6cebfd796ed7947b071d4ba1ce6f1014a3 100644
--- a/src/xercesc/validators/schema/identity/XPathMatcher.hpp
+++ b/src/xercesc/validators/schema/identity/XPathMatcher.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -82,21 +82,24 @@ class XMLStringPool;
class XercesLocationPath;
class XMLAttr;
-class VALIDATORS_EXPORT XPathMatcher
+class VALIDATORS_EXPORT XPathMatcher : public XMemory
{
public:
// -----------------------------------------------------------------------
// Constructors/Destructor
// -----------------------------------------------------------------------
- XPathMatcher(XercesXPath* const xpath);
XPathMatcher(XercesXPath* const xpath,
- IdentityConstraint* const ic);
+ MemoryManager* const manager);
+ XPathMatcher(XercesXPath* const xpath,
+ IdentityConstraint* const ic,
+ MemoryManager* const manager);
virtual ~XPathMatcher();
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
IdentityConstraint* getIdentityConstraint() const { return fIdentityConstraint; }
+ MemoryManager* getMemoryManager() const { return fMemoryManager; }
// -----------------------------------------------------------------------
// Match methods
@@ -181,6 +184,7 @@ private:
RefVectorOf<ValueStackOf<int> >* fStepIndexes;
RefVectorOf<XercesLocationPath>* fLocationPaths;
IdentityConstraint* fIdentityConstraint;
+ MemoryManager* fMemoryManager;
};
// ---------------------------------------------------------------------------
@@ -188,9 +192,9 @@ private:
// ---------------------------------------------------------------------------
inline void XPathMatcher::cleanUp() {
- delete [] fMatched;
- delete [] fNoMatchDepth;
- delete [] fCurrentStep;
+ fMemoryManager->deallocate(fMatched);//delete [] fMatched;
+ fMemoryManager->deallocate(fNoMatchDepth);//delete [] fNoMatchDepth;
+ fMemoryManager->deallocate(fCurrentStep);//delete [] fCurrentStep;
delete fStepIndexes;
}
diff --git a/src/xercesc/validators/schema/identity/XPathMatcherStack.cpp b/src/xercesc/validators/schema/identity/XPathMatcherStack.cpp
index 2875f2aaf9e650fb6200c9668186333beb3dfab0..8509f93a41c8e573a7f8a0872228227e16ac8d59 100644
--- a/src/xercesc/validators/schema/identity/XPathMatcherStack.cpp
+++ b/src/xercesc/validators/schema/identity/XPathMatcherStack.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.3 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.2 2002/11/04 14:47:41 tng
* C++ Namespace Support.
*
@@ -77,13 +80,13 @@ XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// XPathMatherStack: Constructors and Destructor
// ---------------------------------------------------------------------------
-XPathMatcherStack::XPathMatcherStack()
+XPathMatcherStack::XPathMatcherStack(MemoryManager* const manager)
: fMatchersCount(0)
- , fContextStack(new ValueStackOf<int>(8))
+ , fContextStack(new (manager) ValueStackOf<int>(8))
, fMatchers(0)
{
try {
- fMatchers = new RefVectorOf<XPathMatcher>(8);
+ fMatchers = new (manager) RefVectorOf<XPathMatcher>(8);
}
catch(...) {
diff --git a/src/xercesc/validators/schema/identity/XPathMatcherStack.hpp b/src/xercesc/validators/schema/identity/XPathMatcherStack.hpp
index 80088d3539f20cc9c8909228455e66ff6070a41f..3b5dc8b9bca3834d1f804b4b24a22fd7631b583a 100644
--- a/src/xercesc/validators/schema/identity/XPathMatcherStack.hpp
+++ b/src/xercesc/validators/schema/identity/XPathMatcherStack.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -69,13 +69,13 @@
XERCES_CPP_NAMESPACE_BEGIN
-class VALIDATORS_EXPORT XPathMatcherStack
+class VALIDATORS_EXPORT XPathMatcherStack : public XMemory
{
public:
// -----------------------------------------------------------------------
// Constructors/Destructor
// -----------------------------------------------------------------------
- XPathMatcherStack();
+ XPathMatcherStack(MemoryManager* const manager);
~XPathMatcherStack();
// -----------------------------------------------------------------------
diff --git a/src/xercesc/validators/schema/identity/XercesXPath.cpp b/src/xercesc/validators/schema/identity/XercesXPath.cpp
index a4658ccac4a3b1f72bc272f0ff74cbe74450e5e3..2bd07f6989ebbbca1244250510084f48ece56c72 100644
--- a/src/xercesc/validators/schema/identity/XercesXPath.cpp
+++ b/src/xercesc/validators/schema/identity/XercesXPath.cpp
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.6 2003/05/15 18:59:34 knoaman
+ * Partial implementation of the configurable memory manager.
+ *
* Revision 1.5 2002/12/20 22:10:48 tng
* XML 1.1
*
@@ -270,10 +273,13 @@ XercesXPath::XercesXPath(const XMLCh* const xpathExpr,
const unsigned int emptyNamespaceId,
const bool isSelector)
: fEmptyNamespaceId(emptyNamespaceId)
- , fExpression(XMLString::replicate(xpathExpr))
+ , fExpression(0)
, fLocationPaths(0)
+ , fMemoryManager(XMLPlatformUtils::fgMemoryManager)
{
- try {
+ try
+ {
+ fExpression = XMLString::replicate(xpathExpr, fMemoryManager);
parseExpression(stringPool, scopeContext);
if (isSelector) {
@@ -320,7 +326,7 @@ bool XercesXPath::operator!=(const XercesXPath& other) const {
// ---------------------------------------------------------------------------
void XercesXPath::cleanUp() {
- delete [] fExpression;
+ fMemoryManager->deallocate(fExpression);//delete [] fExpression;
delete fLocationPaths;
}
@@ -356,11 +362,11 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
bool success = scanner.scanExpression(fExpression, 0, length, &tokens);
bool firstTokenOfLocationPath=true;
unsigned int tokenCount = tokens.size();
- RefVectorOf<XercesStep>* stepsVector = new RefVectorOf<XercesStep>(16);
+ RefVectorOf<XercesStep>* stepsVector = new (fMemoryManager) RefVectorOf<XercesStep>(16);
Janitor<RefVectorOf<XercesStep> > janSteps(stepsVector);
if (tokenCount) {
- fLocationPaths = new RefVectorOf<XercesLocationPath>(8);
+ fLocationPaths = new (fMemoryManager) RefVectorOf<XercesLocationPath>(8);
}
for (unsigned int i = 0; i < tokenCount; i++) {
@@ -381,9 +387,9 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
ThrowXML(XPathException, XMLExcepts::XPath_NoMultipleUnion);
}
- fLocationPaths->addElement(new XercesLocationPath(stepsVector));
+ fLocationPaths->addElement(new (fMemoryManager) XercesLocationPath(stepsVector));
janSteps.orphan();
- stepsVector = new RefVectorOf<XercesStep>(16);
+ stepsVector = new (fMemoryManager) RefVectorOf<XercesStep>(16);
janSteps.reset(stepsVector);
firstTokenOfLocationPath = true;
}
@@ -414,8 +420,8 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
case XercesXPath::EXPRTOKEN_NAMETEST_ANY:
{
- XercesNodeTest* nodeTest = new XercesNodeTest(XercesNodeTest::WILDCARD);
- XercesStep* step = new XercesStep(XercesStep::ATTRIBUTE, nodeTest);
+ XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::WILDCARD);
+ XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::ATTRIBUTE, nodeTest);
stepsVector->addElement(step);
break;
}
@@ -443,8 +449,8 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
if (isNamespaceAtt) {
// build step
- XercesNodeTest* nodeTest = new XercesNodeTest(prefix, uri);
- XercesStep* step = new XercesStep(XercesStep::ATTRIBUTE, nodeTest);
+ XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(prefix, uri);
+ XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::ATTRIBUTE, nodeTest);
stepsVector->addElement(step);
break;
}
@@ -455,8 +461,8 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
QName aQName(prefix, localPart, uri);
// build step
- XercesNodeTest* nodeTest = new XercesNodeTest(&aQName);
- XercesStep* step = new XercesStep(XercesStep::ATTRIBUTE, nodeTest);
+ XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(&aQName);
+ XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::ATTRIBUTE, nodeTest);
stepsVector->addElement(step);
break;
}
@@ -484,8 +490,8 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
}
case XercesXPath::EXPRTOKEN_NAMETEST_ANY:
{
- XercesNodeTest* nodeTest = new XercesNodeTest(XercesNodeTest::WILDCARD);
- XercesStep* step = new XercesStep(XercesStep::CHILD, nodeTest);
+ XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::WILDCARD);
+ XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::CHILD, nodeTest);
stepsVector->addElement(step);
firstTokenOfLocationPath = false;
break;
@@ -515,8 +521,8 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
if (isNamespace) {
// build step
- XercesNodeTest* nodeTest = new XercesNodeTest(prefix, uri);
- XercesStep* step = new XercesStep(XercesStep::CHILD, nodeTest);
+ XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(prefix, uri);
+ XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::CHILD, nodeTest);
stepsVector->addElement(step);
break;
}
@@ -526,8 +532,8 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
QName aQName(prefix, localPart, uri);
// build step
- XercesNodeTest* nodeTest = new XercesNodeTest(&aQName);
- XercesStep* step = new XercesStep(XercesStep::CHILD, nodeTest);
+ XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(&aQName);
+ XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::CHILD, nodeTest);
stepsVector->addElement(step);
firstTokenOfLocationPath = false;
break;
@@ -535,8 +541,8 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
case XercesXPath::EXPRTOKEN_PERIOD:
{
// build step
- XercesNodeTest* nodeTest = new XercesNodeTest(XercesNodeTest::NODE);
- XercesStep* step = new XercesStep(XercesStep::SELF, nodeTest);
+ XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NODE);
+ XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::SELF, nodeTest);
stepsVector->addElement(step);
if (firstTokenOfLocationPath && i+1 < tokenCount) {
@@ -558,8 +564,8 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
}
}
// build step
- nodeTest = new XercesNodeTest(XercesNodeTest::NODE);
- step = new XercesStep(XercesStep::DESCENDANT, nodeTest);
+ nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NODE);
+ step = new (fMemoryManager) XercesStep(XercesStep::DESCENDANT, nodeTest);
stepsVector->addElement(step);
}
}
@@ -604,7 +610,7 @@ void XercesXPath::parseExpression(XMLStringPool* const stringPool,
}
}
- fLocationPaths->addElement(new XercesLocationPath(stepsVector));
+ fLocationPaths->addElement(new (fMemoryManager) XercesLocationPath(stepsVector));
janSteps.orphan();
}
diff --git a/src/xercesc/validators/schema/identity/XercesXPath.hpp b/src/xercesc/validators/schema/identity/XercesXPath.hpp
index fb711f54ac92f4a877d87c3c9c3fe6984a855735..8210212eb9f32e7319e75d69deaef17a2b3e3381 100644
--- a/src/xercesc/validators/schema/identity/XercesXPath.hpp
+++ b/src/xercesc/validators/schema/identity/XercesXPath.hpp
@@ -1,7 +1,7 @@
/*
* The Apache Software License, Version 1.1
*
- * Copyright (c) 2001 The Apache Software Foundation. All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -78,7 +78,7 @@ class XMLStringPool;
class NamespaceScope;
-class VALIDATORS_EXPORT XercesNodeTest
+class VALIDATORS_EXPORT XercesNodeTest : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -125,7 +125,8 @@ private:
/**
* A location path step comprised of an axis and node test.
*/
-class VALIDATORS_EXPORT XercesStep {
+class VALIDATORS_EXPORT XercesStep : public XMemory
+{
public:
// -----------------------------------------------------------------------
// Constants
@@ -169,7 +170,7 @@ private:
/**
* A location path representation for an XPath expression.
*/
-class VALIDATORS_EXPORT XercesLocationPath
+class VALIDATORS_EXPORT XercesLocationPath : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -206,7 +207,7 @@ private:
};
-class VALIDATORS_EXPORT XercesXPath
+class VALIDATORS_EXPORT XercesXPath : public XMemory
{
public:
// -----------------------------------------------------------------------
@@ -311,10 +312,11 @@ private:
unsigned int fEmptyNamespaceId;
XMLCh* fExpression;
RefVectorOf<XercesLocationPath>* fLocationPaths;
+ MemoryManager* fMemoryManager;
};
-class VALIDATORS_EXPORT XPathScanner
+class VALIDATORS_EXPORT XPathScanner : public XMemory
{
public:
// -----------------------------------------------------------------------