datatypevalidatorfactory.cpp

来自「IBM的解析xml的工具Xerces的源代码」· C++ 代码 · 共 1,087 行 · 第 1/3 页

        // 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;
            }
        }
    }
}

/***
 *
 *   For Decimal-derivated, an instance of DecimalDatatypeValidator
 *   can be used by the primitive datatype, decimal, or any one of 
 *   the derivated datatypes, such as int, long, unsighed short, just
 *   name a few, or any user-defined datatypes, which may derivate from
 *   either the primitive datatype, decimal, or from any one of those 
 *   decimal derivated datatypes, or other user-defined datatypes, which
 *   in turn, indirectly derivate from decimal or decimal-derived.
 *
 *   fCanRepRegisty captures deciaml dv and its derivatives.
 *
 ***/
void DatatypeValidatorFactory::initCanRepRegistory()
{

     /***
      * key:  dv
      * data: XMLCanRepGroup
      ***/
     fCanRepRegistry  = new RefHashTableOf<XMLCanRepGroup>(29, true, new HashPtr() );

     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal));

     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),