DOMElement*
SchemaInfo::getTopLevelComponent(const unsigned short compCategory,
const XMLCh* const compName,
const XMLCh* const name) {
if (compCategory >= C_Count)
return 0;
DOMElement* child = XUtil::getFirstChildElement(fSchemaRootElement);
if (!child)
return 0;
RefHashTableOf<DOMElement>* compList = fTopLevelComponents[compCategory];
if (fTopLevelComponents[compCategory] == 0) {
compList= new (fMemoryManager) RefHashTableOf<DOMElement>(17, false, fMemoryManager);
fTopLevelComponents[compCategory] = compList;
}
else {
DOMElement* cachedChild = compList->get(name);
if(cachedChild)
return cachedChild;
child = fLastTopLevelComponent[compCategory];
}
DOMElement* redefParent = (DOMElement*) child->getParentNode();
// Parent is not "redefine"
if (!XMLString::equals(redefParent->getLocalName(),SchemaSymbols::fgELT_REDEFINE))
redefParent = 0;
while (child != 0) {
fLastTopLevelComponent[compCategory]=child;
if (XMLString::equals(child->getLocalName(), compName)) {
const XMLCh* cName=child->getAttribute(SchemaSymbols::fgATT_NAME);
compList->put((void*)cName, child);
if (XMLString::equals(cName, name))
return child;
}
else if (XMLString::equals(child->getLocalName(),SchemaSymbols::fgELT_REDEFINE)
&& (!fFailedRedefineList || !fFailedRedefineList->containsElement(child))) { // if redefine
DOMElement* redefineChild = XUtil::getFirstChildElement(child);
while (redefineChild != 0) {
fLastTopLevelComponent[compCategory]=redefineChild;
if ((!fFailedRedefineList || !fFailedRedefineList->containsElement(redefineChild))
&& XMLString::equals(redefineChild->getLocalName(), compName)) {
const XMLCh* rName=redefineChild->getAttribute(SchemaSymbols::fgATT_NAME);
compList->put((void*)rName, redefineChild);
if (XMLString::equals(rName, name))
return redefineChild;
}
redefineChild = XUtil::getNextSiblingElement(redefineChild);
}
}
child = XUtil::getNextSiblingElement(child);
if (child == 0 && redefParent) {
child = XUtil::getNextSiblingElement(redefParent);
redefParent = 0;
}
}
return child;
}
void processDatatypeValidator( const DatatypeValidator* dtValidator, bool margin )
{
if( !dtValidator )
{
return;
}
if( margin )
{
XERCES_STD_QUALIFIER cout << "\t";
}
XERCES_STD_QUALIFIER cout << "Base Datatype:\t\t";
switch( dtValidator->getType() )
{
case DatatypeValidator::String: XERCES_STD_QUALIFIER cout << "string"; break;
case DatatypeValidator::AnyURI: XERCES_STD_QUALIFIER cout << "AnyURI"; break;
case DatatypeValidator::QName: XERCES_STD_QUALIFIER cout << "QName"; break;
case DatatypeValidator::Name: XERCES_STD_QUALIFIER cout << "Name"; break;
case DatatypeValidator::NCName: XERCES_STD_QUALIFIER cout << "NCName"; break;
case DatatypeValidator::Boolean: XERCES_STD_QUALIFIER cout << "Boolean"; break;
case DatatypeValidator::Float: XERCES_STD_QUALIFIER cout << "Float"; break;
case DatatypeValidator::Double: XERCES_STD_QUALIFIER cout << "Double"; break;
case DatatypeValidator::Decimal: XERCES_STD_QUALIFIER cout << "Decimal"; break;
case DatatypeValidator::HexBinary: XERCES_STD_QUALIFIER cout << "HexBinary"; break;
case DatatypeValidator::Base64Binary: XERCES_STD_QUALIFIER cout << "Base64Binary";break;
case DatatypeValidator::Duration: XERCES_STD_QUALIFIER cout << "Duration"; break;
case DatatypeValidator::DateTime: XERCES_STD_QUALIFIER cout << "DateTime"; break;
case DatatypeValidator::Date: XERCES_STD_QUALIFIER cout << "Date"; break;
case DatatypeValidator::Time: XERCES_STD_QUALIFIER cout << "Time"; break;
case DatatypeValidator::MonthDay: XERCES_STD_QUALIFIER cout << "MonthDay"; break;
case DatatypeValidator::YearMonth: XERCES_STD_QUALIFIER cout << "YearMonth"; break;
case DatatypeValidator::Year: XERCES_STD_QUALIFIER cout << "Year"; break;
case DatatypeValidator::Month: XERCES_STD_QUALIFIER cout << "Month"; break;
case DatatypeValidator::Day: XERCES_STD_QUALIFIER cout << "Day"; break;
case DatatypeValidator::ID: XERCES_STD_QUALIFIER cout << "ID"; break;
case DatatypeValidator::IDREF: XERCES_STD_QUALIFIER cout << "IDREF"; break;
case DatatypeValidator::ENTITY: XERCES_STD_QUALIFIER cout << "ENTITY"; break;
case DatatypeValidator::NOTATION: XERCES_STD_QUALIFIER cout << "NOTATION"; break;
case DatatypeValidator::List: XERCES_STD_QUALIFIER cout << "List"; break;
case DatatypeValidator::Union: XERCES_STD_QUALIFIER cout << "Union"; break;
case DatatypeValidator::AnySimpleType: XERCES_STD_QUALIFIER cout << "AnySimpleType"; break;
case DatatypeValidator::UnKnown: XERCES_STD_QUALIFIER cout << "UNKNOWN"; break;
}
XERCES_STD_QUALIFIER cout << "\n";
// Facets
RefHashTableOf<KVStringPair>* facets = dtValidator->getFacets();
if( facets && facets->getCount()>0)
{
XMLSize_t i;
// Element's properties
XERCES_STD_QUALIFIER cout << "Facets:\t\t\n";
// use a list to print them sorted, or the list could be different on 64-bit machines
RefVectorOf<XMLCh> sortedList(facets->getCount(), false);
RefHashTableOfEnumerator<KVStringPair> enumFacets(facets);
while( enumFacets.hasMoreElements() )
{
const KVStringPair& curPair = enumFacets.nextElement();
const XMLCh* key=curPair.getKey();
XMLSize_t len=sortedList.size();
for(i=0;i<len;i++)
if(XMLString::compareString(key, sortedList.elementAt(i))<0)
{
sortedList.insertElementAt((XMLCh*)key,i);
break;
}
if(i==len)
sortedList.addElement((XMLCh*)key);
}
XMLSize_t len=sortedList.size();
for(i=0;i<len;i++)
{
const XMLCh* key = sortedList.elementAt(i);
XERCES_STD_QUALIFIER cout << "\t" << StrX( key ) << "="
<< StrX( facets->get(key)->getValue() ) << "\n";
}
}
// Enumerations
RefVectorOf<XMLCh>* enums = (RefVectorOf<XMLCh>*) dtValidator->getEnumString();
if (enums)
{
XERCES_STD_QUALIFIER cout << "Enumeration:\t\t\n";
XMLSize_t enumLength = enums->size();
for ( XMLSize_t i = 0; i < enumLength; i++)
{
XERCES_STD_QUALIFIER cout << "\t" << StrX( enums->elementAt(i)) << "\n";
}
}
}
// ---------------------------------------------------------------------------
// DatatypeValidatorFactory: Registry initialization methods
// ---------------------------------------------------------------------------
void DatatypeValidatorFactory::expandRegistryToFullSchemaSet()
{
if (!sBuiltInRegistryMutexRegistered)
{
if (!sBuiltInRegistryMutex)
{
XMLMutexLock lock(XMLPlatformUtils::fgAtomicMutex);
if (!sBuiltInRegistryMutex)
sBuiltInRegistryMutex = new XMLMutex(XMLPlatformUtils::fgMemoryManager);
}
// Use a faux scope to synchronize while we do this
{
XMLMutexLock lock(sBuiltInRegistryMutex);
// If we got here first, then register it and set the registered flag
if (!sBuiltInRegistryMutexRegistered)
{
//Initialize common Schema/DTD Datatype validator set
fBuiltInRegistry = new RefHashTableOf<DatatypeValidator>(29);
DatatypeValidator *dv = new StringDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_STRING, dv);
dv = new NOTATIONDatatypeValidator();
dv->setTypeName(XMLUni::fgNotationString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) XMLUni::fgNotationString, dv);
dv = new AnySimpleTypeDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYSIMPLETYPE, dv);
dv = new BooleanDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_BOOLEAN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN, dv);
dv = new DecimalDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL, dv);
dv = new HexBinaryDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_HEXBINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_HEXBINARY, dv);
dv = new Base64BinaryDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_BASE64BINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BASE64BINARY, dv);
dv = new DoubleDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_DOUBLE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DOUBLE, dv);
dv = new FloatDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_FLOAT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_FLOAT, dv);
dv = new AnyURIDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYURI, dv);
dv = new QNameDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_QNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_QNAME, dv);
dv = new DateTimeDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_DATETIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATETIME, dv);
dv = new DateDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_DATE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATE, dv);
dv = new TimeDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_TIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_TIME, dv);
dv = new DayDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_DAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DAY, dv);
dv = new MonthDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_MONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTH, dv);
dv = new MonthDayDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_MONTHDAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTHDAY, dv);
dv = new YearDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_YEAR, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEAR, dv);
dv = new YearMonthDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_YEARMONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEARMONTH, dv);
dv = new DurationDatatypeValidator();
dv->setTypeName(SchemaSymbols::fgDT_DURATION, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DURATION, dv);
// REVISIT
// We are creating a lot of Hashtables for the facets of the different
// validators. It's better to have some kind of a memory pool and ask
// the pool to give us a new instance of the hashtable.
RefHashTableOf<KVStringPair>* facets = new RefHashTableOf<KVStringPair>(3);
// Create 'normalizedString' datatype validator
facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_REPLACE));
createDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING,
getDatatypeValidator(SchemaSymbols::fgDT_STRING),
facets, 0, false, 0, false);
// Create 'token' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
createDatatypeValidator(SchemaSymbols::fgDT_TOKEN,
getDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING),
facets, 0, false, 0, false);
dv = new NameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_TOKEN), 0, 0, 0);
dv->setTypeName(SchemaSymbols::fgDT_NAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NAME, dv);
dv = new NCNameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NAME), 0, 0, 0);
dv->setTypeName(SchemaSymbols::fgDT_NCNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NCNAME, dv);
// Create 'NMTOKEN' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
facets->put((void*) SchemaSymbols::fgELT_PATTERN ,
new KVStringPair(SchemaSymbols::fgELT_PATTERN,fgTokPattern));
facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
createDatatypeValidator(XMLUni::fgNmTokenString,
getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),facets, 0, false, 0, false);
// Create 'NMTOKENS' datatype validator
createDatatypeValidator(XMLUni::fgNmTokensString,
getDatatypeValidator(XMLUni::fgNmTokenString), 0, 0, true, 0, false);
// Create 'language' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
facets->put((void*) SchemaSymbols::fgELT_PATTERN,
new KVStringPair(SchemaSymbols::fgELT_PATTERN, XMLUni::fgLangPattern));
createDatatypeValidator(SchemaSymbols::fgDT_LANGUAGE,
getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),
facets, 0, false, 0, false);
// Create 'integer' datatype validator
facets = new RefHashTableOf<KVStringPair>(3);
facets->put((void*) SchemaSymbols::fgELT_FRACTIONDIGITS,
new KVStringPair(SchemaSymbols::fgELT_FRACTIONDIGITS, XMLUni::fgValueZero));
facets->put((void*) SchemaSymbols::fgELT_PATTERN,
new KVStringPair(SchemaSymbols::fgELT_PATTERN, fgIntegerPattern));
createDatatypeValidator(SchemaSymbols::fgDT_INTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
facets, 0, false, 0, false);
// Create 'nonPositiveInteger' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgValueZero));
createDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
facets, 0, false, 0, false);
// Create 'negativeInteger' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgNegOne));
createDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER),
facets, 0, false, 0, false);
// Create 'long' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgLongMaxInc));
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgLongMinInc));
createDatatypeValidator(SchemaSymbols::fgDT_LONG,
getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
facets, 0, false, 0, false);
// Create 'int' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgIntMaxInc));
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgIntMinInc));
createDatatypeValidator(SchemaSymbols::fgDT_INT,
getDatatypeValidator(SchemaSymbols::fgDT_LONG),
facets, 0, false, 0, false);
// Create 'short' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgShortMaxInc));
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgShortMinInc));
createDatatypeValidator(SchemaSymbols::fgDT_SHORT,
getDatatypeValidator(SchemaSymbols::fgDT_INT),
facets, 0, false, 0 ,false);
// Create 'byte' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgByteMaxInc));
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgByteMinInc));
createDatatypeValidator(SchemaSymbols::fgDT_BYTE,
getDatatypeValidator(SchemaSymbols::fgDT_SHORT),
facets, 0, false, 0, false);
// Create 'nonNegativeInteger' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueZero));
createDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
facets, 0, false, 0, false);
// Create 'unsignedLong' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgULongMaxInc));
createDatatypeValidator(SchemaSymbols::fgDT_ULONG,
getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
facets, 0, false, 0, false);
// Create 'unsignedInt' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUIntMaxInc));
createDatatypeValidator(SchemaSymbols::fgDT_UINT,
getDatatypeValidator(SchemaSymbols::fgDT_ULONG),
facets, 0, false, 0, false);
// Create 'unsignedShort' datatypeValidator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUShortMaxInc));
createDatatypeValidator(SchemaSymbols::fgDT_USHORT,
getDatatypeValidator(SchemaSymbols::fgDT_UINT),
facets, 0, false, 0, false);
// Create 'unsignedByte' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUByteMaxInc));
createDatatypeValidator(SchemaSymbols::fgDT_UBYTE,
getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
facets, 0, false, 0, false);
// Create 'positiveInteger' datatype validator
facets = new RefHashTableOf<KVStringPair>(2);
facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueOne));
createDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER,
getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
facets, 0, false, 0, false);
// Create 'ID', 'IDREF' and 'ENTITY' datatype validator
dv = new IDDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
dv->setTypeName(XMLUni::fgIDString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) XMLUni::fgIDString, dv);
dv = new IDREFDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
dv->setTypeName(XMLUni::fgIDRefString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) XMLUni::fgIDRefString, dv);
dv = new ENTITYDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
dv->setTypeName(XMLUni::fgEntityString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
fBuiltInRegistry->put((void*) XMLUni::fgEntityString, dv);
// Create 'IDREFS' datatype validator
createDatatypeValidator
(
XMLUni::fgIDRefsString
, getDatatypeValidator(XMLUni::fgIDRefString)
, 0
, 0
, true
, 0
, false
);
// Create 'ENTITIES' datatype validator
createDatatypeValidator
(
XMLUni::fgEntitiesString
, getDatatypeValidator(XMLUni::fgEntityString)
, 0
, 0
, true
, 0
, false
);
initCanRepRegistory();
// register cleanup method
builtInRegistryCleanup.registerCleanup(DatatypeValidatorFactory::reinitRegistry);
sBuiltInRegistryMutexRegistered = true;
}
}
}
}
// ---------------------------------------------------------------------------
// DatatypeValidatorFactory: factory methods
// ---------------------------------------------------------------------------
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
, MemoryManager* const userManager
)
{
if (baseValidator == 0) {
if (facets) {
Janitor<KVStringPairHashTable> janFacets(facets);
}
if (enums) {
Janitor<XMLChRefVector> janEnums(enums);
}
return 0;
}
DatatypeValidator* datatypeValidator = 0;
MemoryManager* const manager = (isUserDefined)
? userManager : XMLPlatformUtils::fgMemoryManager;
if (isDerivedByList) {
datatypeValidator = new (manager) ListDatatypeValidator(baseValidator, facets, enums, finalSet, manager);
// Set PSVI information for Ordered, Numeric, Bounded & Finite
datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_FALSE);
datatypeValidator->setNumeric(false);
if (facets &&
((facets->get(SchemaSymbols::fgELT_LENGTH) ||
(facets->get(SchemaSymbols::fgELT_MINLENGTH) && facets->get(SchemaSymbols::fgELT_MAXLENGTH)))))
{
datatypeValidator->setBounded(true);
datatypeValidator->setFinite(true);
}
else
{
datatypeValidator->setBounded(false);
datatypeValidator->setFinite(false);
}
}
else {
if ((baseValidator->getType() != DatatypeValidator::String) && facets) {
KVStringPair* value = facets->get(SchemaSymbols::fgELT_WHITESPACE);
if (value != 0) {
facets->removeKey(SchemaSymbols::fgELT_WHITESPACE);
}
}
datatypeValidator = baseValidator->newInstance
(
facets
, enums
, finalSet
, manager
);
// Set PSVI information for Ordered, Numeric, Bounded & Finite
datatypeValidator->setOrdered(baseValidator->getOrdered());
datatypeValidator->setNumeric(baseValidator->getNumeric());
RefHashTableOf<KVStringPair>* baseFacets = baseValidator->getFacets();
if (facets &&
((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
facets->get(SchemaSymbols::fgELT_MINEXCLUSIVE) ||
(baseFacets && (baseFacets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
baseFacets->get(SchemaSymbols::fgELT_MINEXCLUSIVE))))) &&
(facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE) ||
(baseFacets && ((baseFacets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
baseFacets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE))))))
{
datatypeValidator->setBounded(true);
}
else
{
datatypeValidator->setBounded(false);
}
if (baseValidator->getFinite())
{
datatypeValidator->setFinite(true);
}
else if (!facets)
{
datatypeValidator->setFinite(false);
}
else if (facets->get(SchemaSymbols::fgELT_LENGTH) || facets->get(SchemaSymbols::fgELT_MAXLENGTH) ||
facets->get(SchemaSymbols::fgELT_TOTALDIGITS))
{
datatypeValidator->setFinite(true);
}
//for efficiency use this instead of rechecking...
//else if ((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) || facets->get(SchemaSymbols::fgELT_MINEXCLUSIVE)) &&
// (facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) || facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE)))
else if (datatypeValidator->getBounded() ||
datatypeValidator->getType() == DatatypeValidator::Date ||
datatypeValidator->getType() == DatatypeValidator::YearMonth ||
datatypeValidator->getType() == DatatypeValidator::Year ||
datatypeValidator->getType() == DatatypeValidator::MonthDay ||
datatypeValidator->getType() == DatatypeValidator::Day ||
datatypeValidator->getType() == DatatypeValidator::Month)
{
if (facets->get(SchemaSymbols::fgELT_FRACTIONDIGITS))
{
datatypeValidator->setFinite(true);
}
else
{
datatypeValidator->setFinite(false);
}
}
else
{
datatypeValidator->setFinite(false);
}
}
if (datatypeValidator != 0) {
if (isUserDefined) {
if (!fUserDefinedRegistry) {
fUserDefinedRegistry = new (userManager) RefHashTableOf<DatatypeValidator>(29, userManager);
}
fUserDefinedRegistry->put((void *)typeName, datatypeValidator);
}
else {
fBuiltInRegistry->put((void *)typeName, datatypeValidator);
}
datatypeValidator->setTypeName(typeName);
}
return datatypeValidator;
}
// ---------------------------------------------------------------------------
// DFAContentModel: Private helper methods
// ---------------------------------------------------------------------------
void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
{
unsigned int index;
//
// The first step we need to take is to rewrite the content model using
// our CMNode objects, and in the process get rid of any repetition short
// cuts, converting them into '*' style repetitions or getting rid of
// repetitions altogether.
//
// The conversions done are:
//
// x+ -> (x|x*)
// x? -> (x|epsilon)
//
// This is a relatively complex scenario. What is happening is that we
// create a top level binary node of which the special EOC value is set
// as the right side node. The the left side is set to the rewritten
// syntax tree. The source is the original content model info from the
// decl pool. The rewrite is done by buildSyntaxTree() which recurses the
// decl pool's content of the element and builds a new tree in the
// process.
//
// Note that, during this operation, we set each non-epsilon leaf node's
// DFA state position and count the number of such leafs, which is left
// in the fLeafCount member.
//
CMLeaf* nodeEOC = new (fMemoryManager) CMLeaf
(
new (fMemoryManager) QName
(
XMLUni::fgZeroLenString
, XMLUni::fgZeroLenString
, XMLContentModel::gEOCFakeId
, fMemoryManager
)
, ~0
, true
, fMemoryManager
);
CMNode* nodeOrgContent = buildSyntaxTree(curNode);
fHeadNode = new (fMemoryManager) CMBinaryOp
(
ContentSpecNode::Sequence
, nodeOrgContent
, nodeEOC
, fMemoryManager
);
//
// And handle specially the EOC node, which also must be numbered and
// counted as a non-epsilon leaf node. It could not be handled in the
// above tree build because it was created before all that started. We
// save the EOC position since its used during the DFA building loop.
//
fEOCPos = fLeafCount;
nodeEOC->setPosition(fLeafCount++);
//
// Ok, so now we have to iterate the new tree and do a little more work
// now that we know the leaf count. One thing we need to do is to
// calculate the first and last position sets of each node. This is
// cached away in each of the nodes.
//
// Along the way we also set the leaf count in each node as the maximum
// state count. They must know this in order to create their first/last
// position sets.
//
// We also need to build an array of references to the non-epsilon
// leaf nodes. Since we iterate here the same way as we did during the
// initial tree build (which built their position numbers, we will put
// them in the array according to their position values.
//
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);
//
// And, moving onward... We now need to build the follow position sets
// 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 = (CMStateSet**) fMemoryManager->allocate
(
fLeafCount * sizeof(CMStateSet*)
); //new CMStateSet*[fLeafCount];
for (index = 0; index < fLeafCount; index++)
fFollowList[index] = new (fMemoryManager) CMStateSet(fLeafCount, fMemoryManager);
calcFollowList(fHeadNode);
//
// Check to see whether this content model can handle an empty content,
// which is something we need to optimize by looking now before we
// throw away the info that would tell us that.
//
// If the left node of the head (the top level of the original content)
// is nullable, then its true.
//
fEmptyOk = nodeOrgContent->isNullable();
//
// And finally the big push... Now we build the DFA using all the states
// and the tree we've built up. First we set up the various data
// structures we are going to use while we do this.
//
// First of all we need an array of unique element ids in our content
// model. For each transition table entry, we need a set of contiguous
// indices to represent the transitions for a particular input element.
// So we need to a zero based range of indexes that map to element types.
// This element map provides that mapping.
//
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 (fMemoryManager) QName(fMemoryManager);
if ( (fLeafListType[outIndex] & 0x0f) != ContentSpecNode::Leaf )
if (!fLeafNameTypeVector)
fLeafNameTypeVector = new (fMemoryManager) ContentLeafNameTypeVector(fMemoryManager);
// Get the current leaf's element index
const QName* element = fLeafList[outIndex]->getElement();
const XMLCh* elementRawName = 0;
if (fDTD && element)
elementRawName = element->getRawName();
// See if the current leaf node's element index is in the list
unsigned int inIndex = 0;
for (; inIndex < fElemMapSize; inIndex++)
{
const QName* inElem = fElemMap[inIndex];
if (fDTD) {
if (XMLString::equals(inElem->getRawName(), elementRawName)) {
break;
}
}
else {
if ((fElemMapType[inIndex] == fLeafListType[outIndex]) &&
(inElem->getURI() == element->getURI()) &&
(XMLString::equals(inElem->getLocalPart(), element->getLocalPart()))) {
break;
}
}
}
// If it was not in the list, then add it and bump the map size
if (inIndex == fElemMapSize)
{
fElemMap[fElemMapSize]->setValues(*element);
fElemMapType[fElemMapSize] = fLeafListType[outIndex];
++fElemMapSize;
}
}
// set up the fLeafNameTypeVector object if there is one.
if (fLeafNameTypeVector) {
fLeafNameTypeVector->setValues(fElemMap, fElemMapType, fElemMapSize);
}
/***
* Optimization(Jan, 2001); We sort fLeafList according to
* elemIndex which is *uniquely* associated to each leaf.
* We are *assuming* that each element appears in at least one leaf.
**/
// don't forget to delete it
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++)
{
const QName* element = fElemMap[elemIndex];
const XMLCh* elementRawName = 0;
if (fDTD && element)
elementRawName = element->getRawName();
for (unsigned int leafIndex = 0; leafIndex < fLeafCount; leafIndex++)
{
const QName* leaf = fLeafList[leafIndex]->getElement();
if (fDTD) {
if (XMLString::equals(leaf->getRawName(), elementRawName)) {
fLeafSorter[fSortCount++] = leafIndex;
}
}
else {
if ((fElemMapType[elemIndex] == fLeafListType[leafIndex]) &&
(leaf->getURI() == element->getURI()) &&
(XMLString::equals(leaf->getLocalPart(), element->getLocalPart()))) {
fLeafSorter[fSortCount++] = leafIndex;
}
}
}
fLeafSorter[fSortCount++] = -1;
}
//
// Next lets create some arrays, some that that hold transient info
// during the DFA build and some that are permament. These are kind of
// sticky since we cannot know how big they will get, but we don't want
// to use any collection type classes because of performance.
//
// Basically they will probably be about fLeafCount*2 on average, but can
// be as large as 2^(fLeafCount*2), worst case. So we start with
// fLeafCount*4 as a middle ground. This will be very unlikely to ever
// have to expand though, it if does, the overhead will be somewhat ugly.
//
unsigned int curArraySize = fLeafCount * 4;
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 (fMemoryManager) CMStateSet(fHeadNode->getFirstPos());
//
// Init our two state flags. Basically the unmarked state counter is
// always chasing the current state counter. When it catches up, that
// means we made a pass through that did not add any new states to the
// lists, at which time we are done. We could have used a expanding array
// of flags which we used to mark off states as we complete them, but
// this is easier though less readable maybe.
//
unsigned int unmarkedState = 0;
unsigned int curState = 0;
//
// Init the first transition table entry, and put the initial state
// into the states to do list, then bump the current state.
//
fTransTable[curState] = makeDefStateList();
statesToDo[curState] = setT;
curState++;
//
// the stateTable is an auxiliary means to fast
// identification of new state created (instead
// of squential loop statesToDo to find out),
// while the role that statesToDo plays remain unchanged.
//
// TODO: in the future, we may change the 29 to something
// derived from curArraySize.
RefHashTableOf<XMLInteger> *stateTable =
new (fMemoryManager) RefHashTableOf<XMLInteger>
(
curArraySize
, true
, new (fMemoryManager) HashCMStateSet()
, fMemoryManager
);
//stateTable->put((CMStateSet*)setT, new (fMemoryManager) XMLInteger(0));
//
// Ok, almost done with the algorithm from hell... We now enter the
// loop where we go until the states done counter catches up with
// the states to do counter.
//
CMStateSet* newSet = 0;
while (unmarkedState < curState)
{
//
// Get the next unmarked state out of the list of states to do.
// And get the associated transition table entry.
//
setT = statesToDo[unmarkedState];
unsigned int* transEntry = fTransTable[unmarkedState];
// Mark this one final if it contains the EOC state
fFinalStateFlags[unmarkedState] = setT->getBit(fEOCPos);
// Bump up the unmarked state count, marking this state done
unmarkedState++;
// Optimization(Jan, 2001)
unsigned int sorterIndex = 0;
// Optimization(Jan, 2001)
// Loop through each possible input symbol in the element map
for (unsigned int elemIndex = 0; elemIndex < fElemMapSize; elemIndex++)
{
//
// Build up a set of states which is the union of all of the
// follow sets of DFA positions that are in the current state. If
// we gave away the new set last time through then create a new
// one. Otherwise, zero out the existing one.
//
if (!newSet)
newSet = new (fMemoryManager) CMStateSet
(
fLeafCount
, fMemoryManager
);
else
newSet->zeroBits();
#ifdef OBSOLETED
// unoptimized code
for (unsigned int leafIndex = 0; leafIndex < fLeafCount; leafIndex++)
{
// If this leaf index (DFA position) is in the current set...
if (setT->getBit(leafIndex))
{
//
// If this leaf is the current input symbol, then we want
// to add its follow list to the set of states to transition
// to from the current state.
//
const QName* leaf = fLeafList[leafIndex]->getElement();
const QName* element = fElemMap[elemIndex];
if (fDTD) {
if (XMLString::equals(leaf->getRawName(), element->getRawName())) {
*newSet |= *fFollowList[leafIndex];
}
}
else {
if ((leaf->getURI() == element->getURI()) &&
(XMLString::equals(leaf->getLocalPart(), element->getLocalPart()))) {
*newSet |= *fFollowList[leafIndex];
}
}
}
} // for leafIndex
#endif
// Optimization(Jan, 2001)
int leafIndex = fLeafSorter[sorterIndex++];
while (leafIndex != -1)
{
// If this leaf index (DFA position) is in the current set...
if (setT->getBit(leafIndex))
{
//
// If this leaf is the current input symbol, then we
// want to add its follow list to the set of states to
// transition to from the current state.
//
*newSet |= *fFollowList[leafIndex];
}
leafIndex = fLeafSorter[sorterIndex++];
} // while (leafIndex != -1)
//
// If this new set is not empty, then see if its in the list
// of states to do. If not, then add it.
//
if (!newSet->isEmpty())
{
//
// Search the 'states to do' list to see if this new
// state set is already in there.
//
/***
unsigned int stateIndex = 0;
for (; stateIndex < curState; stateIndex++)
{
if (*statesToDo[stateIndex] == *newSet)
break;
}
***/
XMLInteger *stateObj = (XMLInteger*) (stateTable->get(newSet));
unsigned int stateIndex = (stateObj == 0 ? curState : stateObj->intValue());
// If we did not find it, then add it
if (stateIndex == curState)
{
//
// Put this new state into the states to do and init
// a new entry at the same index in the transition
// table.
//
statesToDo[curState] = newSet;
fTransTable[curState] = makeDefStateList();
stateTable->put
(
newSet
, new (fMemoryManager) XMLInteger(curState)
);
// We now have a new state to do so bump the count
curState++;
//
// Null out the new set to indicate we adopted it. This
// will cause the creation of a new set on the next time
// around the loop.
//
newSet = 0;
}
//
// Now set this state in the transition table's entry for this
// element (using its index), with the DFA state we will move
// to from the current state when we see this input element.
//
transEntry[elemIndex] = stateIndex;
// Expand the arrays if we're full
if (curState == curArraySize)
{
//
// Yikes, we overflowed the initial array size, so we've
// got to expand all of these arrays. So adjust up the
// size by 50% and allocate new arrays.
//
const unsigned int newSize = (unsigned int)(curArraySize * 1.5);
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++)
{
newToDo[expIndex] = statesToDo[expIndex];
newFinalFlags[expIndex] = fFinalStateFlags[expIndex];
newTransTable[expIndex] = fTransTable[expIndex];
}
// Clean up the old stuff
fMemoryManager->deallocate(statesToDo); //delete [] statesToDo;
fMemoryManager->deallocate(fFinalStateFlags); //delete [] fFinalStateFlags;
fMemoryManager->deallocate(fTransTable); //delete [] fTransTable;
// Store the new array size and pointers
curArraySize = newSize;
statesToDo = newToDo;
fFinalStateFlags = newFinalFlags;
fTransTable = newTransTable;
} //if (curState == curArraySize)
} //if (!newSet->isEmpty())
} // for elemIndex
} //while
// Store the current state count in the trans table size
fTransTableSize = curState;
// If the last temp set was not stored, then clean it up
if (newSet)
delete newSet;
//
// Now we can clean up all of the temporary data that was needed during
// DFA build.
//
//
// Note on memory leak: Bugzilla#2707:
// ===================================
// The CMBinary, pointed to by fHeadNode, shall be released by
// deleted by itself.
//
// Change has been made to postTreeBuildInit() such that fLeafList[]
// would maintain its **OWN** copy of CMLeaf to avoid double deletion
// of CMLeaf.
//
delete fHeadNode;
for (index = 0; index < fLeafCount; index++)
delete fFollowList[index];
fMemoryManager->deallocate(fFollowList); //delete [] fFollowList;
//
// removeAll() will delete all data, XMLInteger,
// while the keys are to be deleted by the
// deletion of statesToDo.
//
delete stateTable;
for (index = 0; index < curState; index++)
delete (CMStateSet*)statesToDo[index];
fMemoryManager->deallocate(statesToDo); //delete [] statesToDo;
for (index = 0; index < fLeafCount; index++)
delete fLeafList[index];
fMemoryManager->deallocate(fLeafList); //delete [] fLeafList;
fMemoryManager->deallocate(fLeafSorter); //delete [] fLeafSorter;
}
