source: icXML/icXML-devel/src/icxercesc/validators/schema/SchemaValidator.hpp @ 2734

Last change on this file since 2734 was 2734, checked in by cameron, 6 years ago

More paths and missing files.

File size: 17.1 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: SchemaValidator.hpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_SCHEMAVALIDATOR_HPP)
23#define XERCESC_INCLUDE_GUARD_SCHEMAVALIDATOR_HPP
24
25#include <icxercesc/framework/XMLValidator.hpp>
26#include <icxercesc/framework/XMLBuffer.hpp>
27#include <xercesc/util/ValueStackOf.hpp>
28#include <xercesc/validators/common/ContentSpecNode.hpp>
29#include <xercesc/validators/schema/SchemaGrammar.hpp>
30#include <xercesc/validators/schema/XSDErrorReporter.hpp>
31#include <icxmlc/XMLConfig.hpp>
32
33XERCES_CPP_NAMESPACE_BEGIN
34
35class GrammarResolver;
36class DatatypeValidator;
37class SchemaElementDecl;
38
39
40
41//
42//  This is a derivative of the abstract validator interface. This class
43//  implements a validator that supports standard XML Schema semantics.
44//  This class handles scanning the of the schema, and provides
45//  the standard validation services against the Schema info it found.
46//
47class VALIDATORS_EXPORT SchemaValidator : public XMLValidator
48{
49public:
50        // -----------------------------------------------------------------------
51        //  Constructors and Destructor
52        // -----------------------------------------------------------------------
53        SchemaValidator
54        (
55                  XMLErrorReporter* const errReporter = 0
56                  , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
57        );
58
59        virtual ~SchemaValidator();
60
61        // -----------------------------------------------------------------------
62        //  Implementation of the XMLValidator interface
63        // -----------------------------------------------------------------------
64        virtual bool checkContent
65        (
66                XMLElementDecl* const           elemDecl
67                , XMLElementDecl ** const       children
68                , XMLSize_t                                     childCount
69                , XMLSize_t*                            indexOfFailingChild
70        );
71
72        virtual void faultInAttr
73        (
74                                XMLAttr&    toFill
75                , const XMLAttDef&  attDef
76        )   const;
77
78        virtual void preContentValidation(bool reuseGrammar,
79                                                                          bool validateDefAttr = false);
80
81        virtual void postParseValidation();
82
83        virtual void reset();
84
85        virtual bool requiresNamespaces() const;
86
87
88        virtual void validateAttrValue
89        (
90                const   XMLAttDef*                  attDef
91                , const XMLCh* const                attrValue
92                , bool                              preValidation = false
93                , const XMLElementDecl*             elemDecl = 0
94        );
95
96        virtual void validateElement
97        (
98                const   XMLElementDecl*             elemDef
99        );
100
101        virtual Grammar* getGrammar() const;
102        virtual void setGrammar(Grammar* aGrammar);
103
104        // -----------------------------------------------------------------------
105        //  Virtual DTD handler interface.
106        // -----------------------------------------------------------------------
107        virtual bool handlesDTD() const;
108
109        // -----------------------------------------------------------------------
110        //  Virtual Schema handler interface. handlesSchema() always return false.
111        // -----------------------------------------------------------------------
112        virtual bool handlesSchema() const;
113
114        // -----------------------------------------------------------------------
115        //  Setter methods
116        // -----------------------------------------------------------------------
117        void setGrammarResolver(GrammarResolver* grammarResolver);
118
119        void setXsiType
120        (
121                const XMLCh* const                      prefix
122                , const XMLCh* const        localPart
123                , const unsigned int        uriId
124        );
125
126        void setNillable(bool isNil);
127        void resetNillable();
128        void setErrorReporter(XMLErrorReporter* const errorReporter);
129        void setExitOnFirstFatal(const bool newValue);
130        void setDatatypeBuffer(const XMLCh* const value);
131        void clearDatatypeBuffer();
132        void normalizeWhiteSpace(DatatypeValidator* dV, const XMLCh* const value, XMLBuffer& toFill, bool bStandalone = false);
133
134        // -----------------------------------------------------------------------
135        //  Getter methods
136        // -----------------------------------------------------------------------
137        ComplexTypeInfo* getCurrentTypeInfo() const;
138        DatatypeValidator *getCurrentDatatypeValidator() const;
139        DatatypeValidator *getMostRecentAttrValidator() const;
140        bool getErrorOccurred() const;
141        bool getIsElemSpecified() const;
142        bool getIsXsiTypeSet() const;
143        const XMLCh* getNormalizedValue() const;
144
145
146        virtual bool checkContent
147        (
148                XMLElementDecl* const
149                , QName** const
150                , XMLSize_t
151                , XMLSize_t*
152        )
153        {
154                DEPRECATED_FEATURE_IN_ICXML;
155        }
156
157
158private:
159        // -----------------------------------------------------------------------
160        //  Unimplemented constructors and operators
161        // -----------------------------------------------------------------------
162        SchemaValidator(const SchemaValidator&);
163        SchemaValidator& operator=(const SchemaValidator&);
164
165        // -----------------------------------------------------------------------
166        //  Element Consistency Checking methods
167        // -----------------------------------------------------------------------
168        void checkRefElementConsistency(SchemaGrammar* const currentGrammar,
169                                                                        const ComplexTypeInfo* const curTypeInfo,
170                                                                        const XercesGroupInfo* const curGroup = 0);
171
172        // -----------------------------------------------------------------------
173        //  Particle Derivation Checking methods
174        // -----------------------------------------------------------------------
175        void checkParticleDerivation(SchemaGrammar* const currentGrammar,
176                                                                 const ComplexTypeInfo* const typeInfo);
177        void checkParticleDerivationOk(SchemaGrammar* const currentGrammar,
178                                                                   ContentSpecNode* const curNode,
179                                                                   const int derivedScope,
180                                                                   ContentSpecNode* const baseNode,
181                                                                   const int baseScope,
182                                                                   const ComplexTypeInfo* const baseInfo = 0,
183                                                                   const bool toCheckOccurrence = true);
184        ContentSpecNode* checkForPointlessOccurrences(ContentSpecNode* const specNode,
185                                                                                                  const ContentSpecNode::NodeTypes nodeType,
186                                                                                                  ValueVectorOf<ContentSpecNode*>* const nodes);
187        void gatherChildren(const ContentSpecNode::NodeTypes parentNodeType,
188                                                ContentSpecNode* const specNode,
189                                                ValueVectorOf<ContentSpecNode*>* const nodes);
190        bool isOccurrenceRangeOK(const int min1, const int max1, const int min2, const int max2);
191        void checkNSCompat(const ContentSpecNode* const derivedSpecNode,
192                                           const ContentSpecNode* const baseSpecNode,
193                                           const bool toCheckOccurence);
194        bool wildcardEltAllowsNamespace(const ContentSpecNode* const baseSpecNode,
195                                                                        const unsigned int derivedURI);
196        void checkNameAndTypeOK(SchemaGrammar* const currentGrammar,
197                                                        const ContentSpecNode* const derivedSpecNode,
198                                                        const int derivedScope,
199                                                        const ContentSpecNode* const baseSpecNode,
200                                                        const int baseScope,
201                                                        const ComplexTypeInfo* const baseInfo = 0);
202        SchemaElementDecl* findElement(const int scope,
203                                                                   const unsigned int uriIndex,
204                                                                   const XMLCh* const name,
205                                                                   SchemaGrammar* const grammar,
206                                                                   const ComplexTypeInfo* const typeInfo = 0);
207        void checkICRestriction(const SchemaElementDecl* const derivedElemDecl,
208                                                        const SchemaElementDecl* const baseElemDecl,
209                                                        const XMLCh* const derivedElemName,
210                                                        const XMLCh* const baseElemName);
211        void checkTypesOK(const SchemaElementDecl* const derivedElemDecl,
212                                          const SchemaElementDecl* const baseElemDecl,
213                                          const XMLCh* const derivedElemName);
214        void checkRecurseAsIfGroup(SchemaGrammar* const currentGrammar,
215                                                           ContentSpecNode* const derivedSpecNode,
216                                                           const int derivedScope,
217                                                           const ContentSpecNode* const baseSpecNode,
218                                                           const int baseScope,
219                                                           ValueVectorOf<ContentSpecNode*>* const nodes,
220                                                           const ComplexTypeInfo* const baseInfo);
221        void checkRecurse(SchemaGrammar* const currentGrammar,
222                                          const ContentSpecNode* const derivedSpecNode,
223                                          const int derivedScope,
224                                          ValueVectorOf<ContentSpecNode*>* const derivedNodes,
225                                          const ContentSpecNode* const baseSpecNode,
226                                          const int baseScope,
227                                          ValueVectorOf<ContentSpecNode*>* const baseNodes,
228                                          const ComplexTypeInfo* const baseInfo,
229                                          const bool toLax = false);
230        void checkNSSubset(const ContentSpecNode* const derivedSpecNode,
231                                           const ContentSpecNode* const baseSpecNode);
232        bool checkNSSubsetChoiceRoot(const ContentSpecNode* const derivedSpecNode,
233                                           const ContentSpecNode* const baseSpecNode);
234        bool checkNSSubsetChoice(const ContentSpecNode* const derivedSpecNode,
235                                           const ContentSpecNode* const baseSpecNode);
236        bool isWildCardEltSubset(const ContentSpecNode* const derivedSpecNode,
237                                                         const ContentSpecNode* const baseSpecNode);
238        void checkNSRecurseCheckCardinality(SchemaGrammar* const currentGrammar,
239                                                                                const ContentSpecNode* const derivedSpecNode,
240                                                                                ValueVectorOf<ContentSpecNode*>* const derivedNodes,
241                                                                                const int derivedScope,
242                                                                                ContentSpecNode* const baseSpecNode,
243                                                                                const bool toCheckOccurence);
244        void checkRecurseUnordered(SchemaGrammar* const currentGrammar,
245                                                           const ContentSpecNode* const derivedSpecNode,
246                                                           ValueVectorOf<ContentSpecNode*>* const derivedNodes,
247                                                           const int derivedScope,
248                                                           ContentSpecNode* const baseSpecNode,
249                                                           ValueVectorOf<ContentSpecNode*>* const baseNodes,
250                                                           const int baseScope,
251                                                           const ComplexTypeInfo* const baseInfo);
252        void checkMapAndSum(SchemaGrammar* const currentGrammar,
253                                                const ContentSpecNode* const derivedSpecNode,
254                                                ValueVectorOf<ContentSpecNode*>* const derivedNodes,
255                                                const int derivedScope,
256                                                ContentSpecNode* const baseSpecNode,
257                                                ValueVectorOf<ContentSpecNode*>* const baseNodes,
258                                                const int baseScope,
259                                                const ComplexTypeInfo* const baseInfo);
260        ContentSpecNode* getNonUnaryGroup(ContentSpecNode* const pNode);
261
262        // -----------------------------------------------------------------------
263        //  Private data members
264        //
265        // -----------------------------------------------------------------------
266        //  The following comes from or set by the Scanner
267        //  fSchemaGrammar
268        //      The current schema grammar used by the validator
269        //
270        //  fGrammarResolver
271        //      All the schema grammar stored
272        //
273        //  fXsiType
274        //      Store the Schema Type Attribute Value if schema type is specified
275        //
276        //  fNil
277        //      Indicates if a nil value is acceptable
278        //  fNilFound
279        //      Indicates if Nillable has been set
280        // -----------------------------------------------------------------------
281        //  The following used internally in the validator
282        //
283        //  fCurrentDatatypeValidator
284        //      The validator used for validating the content of elements
285        //      with simple types
286        //
287        //  fDatatypeBuffer
288        //      Buffer for simple type element string content
289        //
290        //  fTrailing
291        //      Previous chunk had a trailing space
292        //
293        //  fSeenNonWhiteSpace
294        //      Seen a non-whitespace character in the previous chunk
295        //
296        //  fSeenId
297        //      Indicate if an attribute of ID type has been seen already, reset per element.
298        //
299        //  fSchemaErrorReporter
300        //      Report schema process errors
301        //
302        //  fTypeStack
303        //      Stack of complex type declarations.
304        //
305        //  fMostRecentAttrValidator
306        //      DatatypeValidator that validated attribute most recently processed
307        //
308        //  fErrorOccurred
309        //      whether an error occurred in the most recent operation
310        // -----------------------------------------------------------------------
311        MemoryManager*                  fMemoryManager;
312        SchemaGrammar*                  fSchemaGrammar;
313        GrammarResolver*                fGrammarResolver;
314        QName*                          fXsiType;
315        bool                            fNil;
316        bool                            fNilFound;
317        DatatypeValidator*              fCurrentDatatypeValidator;
318        XMLBuffer*                      fNotationBuf;
319#ifndef REMOVE_XERCES_WHITESPACE_NORMALIZATION
320        XMLBuffer                       fDatatypeBuffer;
321#endif
322        bool                            fTrailing;
323        bool                            fSeenNonWhiteSpace;
324        bool                            fSeenId;
325        XSDErrorReporter                fSchemaErrorReporter;
326        ValueStackOf<ComplexTypeInfo*>  fTypeStack;
327        DatatypeValidator *             fMostRecentAttrValidator;
328        bool                            fErrorOccurred;
329        bool                            fElemIsSpecified;
330};
331
332
333// ---------------------------------------------------------------------------
334//  SchemaValidator: Setter methods
335// ---------------------------------------------------------------------------
336inline void SchemaValidator::setGrammarResolver(GrammarResolver* grammarResolver)
337{
338        fGrammarResolver = grammarResolver;
339}
340
341inline void SchemaValidator::setXsiType
342(
343        const XMLCh* const        prefix
344        , const XMLCh* const      localPart
345        , const unsigned int      uriId
346)
347{
348        DEBUG_MESSAGE("SchemaValidator::setXsiType(" << prefix << ',' << localPart << ',' << uriId << ')');
349        delete fXsiType;
350        fXsiType = new (fMemoryManager) QName(prefix, localPart, uriId, fMemoryManager);
351}
352
353inline void SchemaValidator::setNillable(bool isNil)
354{
355        DEBUG_MESSAGE("SchemaValidator::setNillable(" << isNil << ')');
356        fNil = isNil;
357        fNilFound = true;
358}
359
360inline void SchemaValidator::resetNillable()
361{
362        DEBUG_MESSAGE("SchemaValidator::resetNillable()");
363        fNil = false;
364        fNilFound = false;
365}
366
367inline void SchemaValidator::setExitOnFirstFatal(const bool newValue)
368{
369        fSchemaErrorReporter.setExitOnFirstFatal(newValue);
370}
371
372inline void SchemaValidator::setDatatypeBuffer(const XMLCh* const value)
373{
374#ifdef REMOVE_XERCES_WHITESPACE_NORMALIZATION
375        DEPRECATED_FEATURE_IN_ICXML;
376#else
377        fDatatypeBuffer.append(value);
378#endif
379}
380
381inline void SchemaValidator::clearDatatypeBuffer()
382{
383#ifdef REMOVE_XERCES_WHITESPACE_NORMALIZATION
384        DEPRECATED_FEATURE_IN_ICXML;
385#else
386        fDatatypeBuffer.reset();
387#endif
388}
389
390// ---------------------------------------------------------------------------
391//  SchemaValidator: Getter methods
392// ---------------------------------------------------------------------------
393inline ComplexTypeInfo* SchemaValidator::getCurrentTypeInfo() const
394{
395        SchemaValidator* self = const_cast<SchemaValidator*>(this);
396        if (self->fTypeStack.empty())
397        {
398                return 0;
399        }
400        return self->fTypeStack.peek();
401}
402
403inline DatatypeValidator * SchemaValidator::getCurrentDatatypeValidator() const
404{
405        return fCurrentDatatypeValidator;
406}
407inline DatatypeValidator *SchemaValidator::getMostRecentAttrValidator() const
408{
409        return fMostRecentAttrValidator;
410}
411
412// ---------------------------------------------------------------------------
413//  Virtual interface
414// ---------------------------------------------------------------------------
415inline Grammar* SchemaValidator::getGrammar() const
416{
417        return fSchemaGrammar;
418}
419
420inline void SchemaValidator::setGrammar(Grammar* aGrammar)
421{
422        fSchemaGrammar = (SchemaGrammar*) aGrammar;
423}
424
425inline void SchemaValidator::setErrorReporter(XMLErrorReporter* const errorReporter)
426{
427        XMLValidator::setErrorReporter(errorReporter);
428        fSchemaErrorReporter.setErrorReporter(errorReporter);
429}
430
431// ---------------------------------------------------------------------------
432//  SchemaValidator: DTD handler interface
433// ---------------------------------------------------------------------------
434inline bool SchemaValidator::handlesDTD() const
435{
436        // No DTD scanning
437        return false;
438}
439
440// ---------------------------------------------------------------------------
441//  SchemaValidator: Schema handler interface
442// ---------------------------------------------------------------------------
443inline bool SchemaValidator::handlesSchema() const
444{
445        return true;
446}
447
448// ---------------------------------------------------------------------------
449//  SchemaValidator: Particle derivation checking
450// ---------------------------------------------------------------------------
451inline bool
452SchemaValidator::isOccurrenceRangeOK(const int min1, const int max1,
453                                                                         const int min2, const int max2) {
454
455        if (min1 >= min2 &&
456                (max2 == SchemaSymbols::XSD_UNBOUNDED || (max1 != SchemaSymbols::XSD_UNBOUNDED && max1 <= max2)))
457        {
458                return true;
459        }
460        return false;
461}
462
463inline bool SchemaValidator::getErrorOccurred() const
464{
465        return fErrorOccurred;
466}
467
468inline bool SchemaValidator::getIsElemSpecified() const
469{
470        return fElemIsSpecified;
471}
472
473inline const XMLCh* SchemaValidator::getNormalizedValue() const
474{
475#ifdef REMOVE_XERCES_WHITESPACE_NORMALIZATION
476        DEPRECATED_FEATURE_IN_ICXML;
477#else
478        return fDatatypeBuffer.getRawBuffer();
479#endif
480}
481
482inline bool SchemaValidator::getIsXsiTypeSet() const
483{
484        return (fXsiType != 0);
485}
486
487#ifdef PRINT_DEBUG_MESSAGE
488static std::ostream & operator << (std::ostream & out, const SchemaValidator * validator)
489{
490        if (validator)
491        {
492                out << "(SchemaValidator: "
493                        << validator->getCurrentTypeInfo()
494                        << ',' << validator->getIsXsiTypeSet()
495                        << ',' << validator->getGrammar()
496                        << ',' << validator->getCurrentDatatypeValidator()
497                        << ',' << validator->getNormalizedValue()
498                        << ')';
499        }
500        else
501        {
502                out << "(SchemaValidator: NIL)";
503        }
504        return out;
505}
506#endif
507
508XERCES_CPP_NAMESPACE_END
509
510#endif
Note: See TracBrowser for help on using the repository browser.