source: icXML/icXML-devel/src/icxercesc/validators/schema/SchemaInfo.hpp @ 3157

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

Fixes for icXML 0.9

File size: 14.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: SchemaInfo.hpp 925236 2010-03-19 14:29:47Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_SCHEMAINFO_HPP)
23#define XERCESC_INCLUDE_GUARD_SCHEMAINFO_HPP
24
25
26/** When in a <redefine>, type definitions being used (and indeed
27  * refs to <group>'s and <attributeGroup>'s) may refer to info
28  * items either in the schema being redefined, in the <redefine>,
29  * or else in the schema doing the redefining.  Because of this
30  * latter we have to be prepared sometimes to look for our type
31  * definitions outside the schema stored in fSchemaRootElement.
32  * This simple class does this; it's just a linked list that
33  * lets us look at the <schema>'s on the queue; note also that this
34  * should provide us with a mechanism to handle nested <redefine>'s.
35  * It's also a handy way of saving schema info when importing/including.
36  */
37
38// ---------------------------------------------------------------------------
39//  Includes
40// ---------------------------------------------------------------------------
41#include <xercesc/dom/DOMElement.hpp>
42#include <xercesc/util/RefVectorOf.hpp>
43#include <xercesc/util/ValueVectorOf.hpp>
44#include <icxercesc/util/RefHashTableOf.hpp>
45#include <icxmlc/XMLConfig.hpp>
46
47XERCES_CPP_NAMESPACE_BEGIN
48
49// ---------------------------------------------------------------------------
50//  Forward Declarations
51// ---------------------------------------------------------------------------
52class XMLScanner;
53class ValidationContext;
54class NamespaceScope;
55
56class VALIDATORS_EXPORT SchemaInfo : public XMemory
57{
58public:
59
60        enum ListType {
61                // Redefine is treated as an include
62                IMPORT = 1,
63                INCLUDE = 2
64        };
65
66        enum {
67                C_ComplexType,
68                C_SimpleType,
69                C_Group,
70                C_Attribute,
71                C_AttributeGroup,
72                C_Element,
73                C_Notation,
74
75                C_Count
76        };
77
78        // -----------------------------------------------------------------------
79        //  Constructor/Destructor
80        // -----------------------------------------------------------------------
81        SchemaInfo(const unsigned short fElemAttrDefaultQualified,
82                           const int blockDefault,
83                           const int finalDefault,
84                           const int targetNSURI,
85                           const NamespaceScope* const currNamespaceScope,
86                           const XMLCh* const schemaURL,
87                           const XMLCh* const targetNSURIString,
88                           const DOMElement* const root,
89                           XMLScanner* xmlScanner,
90                           MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
91        ~SchemaInfo();
92
93
94        // -----------------------------------------------------------------------
95        //  Getter methods
96        // -----------------------------------------------------------------------
97        XMLCh*                            getCurrentSchemaURL() const;
98        const XMLCh*                      getTargetNSURIString() const;
99        const DOMElement*                 getRoot() const;
100        bool                              getProcessed() const;
101        int                               getBlockDefault() const;
102        int                               getFinalDefault() const;
103        int                               getTargetNSURI() const;
104        NamespaceScope*                   getNamespaceScope() const;
105        unsigned short                    getElemAttrDefaultQualified() const;
106        BaseRefVectorEnumerator<SchemaInfo>   getImportingListEnumerator() const;
107        ValueVectorOf<const DOMElement*>* getRecursingAnonTypes() const;
108        ValueVectorOf<const XMLCh*>*      getRecursingTypeNames() const;
109        ValueVectorOf<DOMNode*>*          getNonXSAttList() const;
110        ValidationContext*                getValidationContext() const;
111
112        // -----------------------------------------------------------------------
113        //  Setter methods
114        // -----------------------------------------------------------------------
115        void setProcessed(const bool aValue = true);
116        void setBlockDefault(const int aValue);
117        void setFinalDefault(const int aValue);
118        void setElemAttrDefaultQualified(const unsigned short aValue);
119        void resetRoot ();
120
121        // -----------------------------------------------------------------------
122        //  Access methods
123        // -----------------------------------------------------------------------
124        void addSchemaInfo(SchemaInfo* const toAdd, const ListType aListType);
125        bool containsInfo(const SchemaInfo* const toCheck, const ListType aListType) const;
126        SchemaInfo* getImportInfo(const unsigned int namespaceURI) const;
127        DOMElement* getTopLevelComponent(const unsigned short compCategory,
128                                                                         const XMLCh* const compName,
129                                                                         const XMLCh* const name);
130        DOMElement* getTopLevelComponent(const unsigned short compCategory,
131                                                                         const XMLCh* const compName,
132                                                                         const XMLCh* const name,
133                                                                         SchemaInfo** enclosingSchema);
134        void updateImportingInfo(SchemaInfo* const importingInfo);
135        bool circularImportExist(const unsigned int nameSpaceURI);
136        bool isFailedRedefine(const DOMElement* const anElem);
137        void addFailedRedefine(const DOMElement* const anElem);
138        void addRecursingType(const DOMElement* const elem, const XMLCh* const name);
139
140private:
141        // -----------------------------------------------------------------------
142        //  Unimplemented constructors and operators
143        // -----------------------------------------------------------------------
144        SchemaInfo(const SchemaInfo&);
145        SchemaInfo& operator=(const SchemaInfo&);
146
147        // -----------------------------------------------------------------------
148        //  Private helper methods
149        // -----------------------------------------------------------------------
150        void clearTopLevelComponents();
151
152        // -----------------------------------------------------------------------
153        //  Private data members
154        // -----------------------------------------------------------------------
155        bool                              fAdoptInclude;
156        bool                              fProcessed;
157        unsigned short                    fElemAttrDefaultQualified;
158        int                               fBlockDefault;
159        int                               fFinalDefault;
160        int                               fTargetNSURI;
161        NamespaceScope*                   fNamespaceScope;
162        XMLCh*                            fCurrentSchemaURL;
163        XMLCh*                            fTargetNSURIString;
164        const DOMElement*                 fSchemaRootElement;
165        RefVectorOf<SchemaInfo>*          fIncludeInfoList;
166        RefVectorOf<SchemaInfo>*          fImportedInfoList;
167        RefVectorOf<SchemaInfo>*          fImportingInfoList;
168        ValueVectorOf<const DOMElement*>* fFailedRedefineList;
169        ValueVectorOf<const DOMElement*>* fRecursingAnonTypes;
170        ValueVectorOf<const XMLCh*>*      fRecursingTypeNames;
171        RefHashTableOf<DOMElement>*       fTopLevelComponents[C_Count];
172        DOMElement*                       fLastTopLevelComponent[C_Count];
173        ValueVectorOf<DOMNode*>*          fNonXSAttList;
174        ValidationContext*                fValidationContext;
175        MemoryManager*                    fMemoryManager;
176};
177
178// ---------------------------------------------------------------------------
179//  SchemaInfo: Getter methods
180// ---------------------------------------------------------------------------
181inline unsigned short SchemaInfo::getElemAttrDefaultQualified() const {
182
183        return fElemAttrDefaultQualified;
184}
185
186inline bool SchemaInfo::getProcessed() const {
187
188        return fProcessed;
189}
190
191inline int SchemaInfo::getBlockDefault() const {
192
193        return fBlockDefault;
194}
195
196inline int SchemaInfo::getFinalDefault() const {
197
198        return fFinalDefault;
199}
200
201inline NamespaceScope* SchemaInfo::getNamespaceScope() const {
202        return fNamespaceScope;
203}
204
205inline XMLCh* SchemaInfo::getCurrentSchemaURL() const {
206
207        return fCurrentSchemaURL;
208}
209
210inline const XMLCh* SchemaInfo::getTargetNSURIString() const {
211
212        return fTargetNSURIString;
213}
214
215inline const DOMElement* SchemaInfo::getRoot() const {
216
217        return fSchemaRootElement;
218}
219
220inline int SchemaInfo::getTargetNSURI() const {
221
222        return fTargetNSURI;
223}
224
225inline BaseRefVectorEnumerator<SchemaInfo>
226SchemaInfo::getImportingListEnumerator() const {
227
228        return BaseRefVectorEnumerator<SchemaInfo>(fImportingInfoList);
229}
230
231inline ValueVectorOf<const DOMElement*>*
232SchemaInfo::getRecursingAnonTypes() const {
233
234        return fRecursingAnonTypes;
235}
236
237
238inline ValueVectorOf<const XMLCh*>*
239SchemaInfo::getRecursingTypeNames() const {
240
241        return fRecursingTypeNames;
242}
243
244inline ValueVectorOf<DOMNode*>* SchemaInfo::getNonXSAttList() const
245{
246        return fNonXSAttList;
247}
248
249// ---------------------------------------------------------------------------
250//  Setter methods
251// ---------------------------------------------------------------------------
252inline void SchemaInfo::setBlockDefault(const int aValue) {
253
254        fBlockDefault = aValue;
255}
256
257inline void SchemaInfo::setFinalDefault(const int aValue) {
258
259        fFinalDefault = aValue;
260}
261
262inline void SchemaInfo::setElemAttrDefaultQualified(const unsigned short aValue) {
263
264        fElemAttrDefaultQualified = aValue;
265}
266
267inline void SchemaInfo::setProcessed(const bool aValue) {
268
269        fProcessed = aValue;
270
271/*    if (fProcessed && fIncludeInfoList) {
272
273                unsigned int includeListLen = fIncludeInfoList->size());
274                for (unsigned int i = 0; i < includeListLen; i++) {
275                        fIncludeInfoList->elementAt(i)->clearTopLevelComponents();
276                }
277        }*/
278}
279
280inline void SchemaInfo::resetRoot ()
281{
282        fSchemaRootElement = 0;
283}
284
285// ---------------------------------------------------------------------------
286//  SchemaInfo: Access methods
287// ---------------------------------------------------------------------------
288inline void SchemaInfo::addSchemaInfo(SchemaInfo* const toAdd,
289                                                                          const ListType aListType) {
290
291        if (aListType == IMPORT) {
292
293                if (!fImportedInfoList)
294                        fImportedInfoList = new (fMemoryManager) RefVectorOf<SchemaInfo>(4, false, fMemoryManager);
295
296                if (!fImportedInfoList->containsElement(toAdd)) {
297
298                        fImportedInfoList->addElement(toAdd);
299                        toAdd->updateImportingInfo(this);
300                }
301        }
302        else {
303
304                if (!fIncludeInfoList) {
305
306                        fIncludeInfoList = new (fMemoryManager) RefVectorOf<SchemaInfo>(8, false, fMemoryManager);
307                        fAdoptInclude = true;
308                }
309
310                if (!fIncludeInfoList->containsElement(toAdd)) {
311
312                        fIncludeInfoList->addElement(toAdd);
313                        //code was originally:
314                        //toAdd->fIncludeInfoList = fIncludeInfoList;
315                        //however for handling multiple imports this was causing
316                        //to schemaInfo's to have the same fIncludeInfoList which they
317                        //both owned so when it was deleted it crashed.
318                        if (toAdd->fIncludeInfoList) {
319                           if (toAdd->fIncludeInfoList != fIncludeInfoList) {
320                                   XMLSize_t size = toAdd->fIncludeInfoList->size();
321                                   for (XMLSize_t i=0; i<size; i++) {
322                                           if (!fIncludeInfoList->containsElement(toAdd->fIncludeInfoList->elementAt(i))) {
323                                                        fIncludeInfoList->addElement(toAdd->fIncludeInfoList->elementAt(i));
324                                           }
325                                   }
326                                   size = fIncludeInfoList->size();
327                                   for (XMLSize_t j=0; j<size; j++) {
328                                           if (!toAdd->fIncludeInfoList->containsElement(fIncludeInfoList->elementAt(j))) {
329                                                        toAdd->fIncludeInfoList->addElement(fIncludeInfoList->elementAt(j));
330                                           }
331                                   }
332                           }
333                        }
334                        else {
335                                toAdd->fIncludeInfoList = fIncludeInfoList;
336                        }
337                }
338        }
339}
340
341inline SchemaInfo* SchemaInfo::getImportInfo(const unsigned int namespaceURI) const {
342
343        XMLSize_t importSize = (fImportedInfoList) ? fImportedInfoList->size() : 0;
344        SchemaInfo* currInfo = 0;
345
346        for (XMLSize_t i=0; i < importSize; i++) {
347
348                currInfo = fImportedInfoList->elementAt(i);
349
350                if (currInfo->getTargetNSURI() == (int) namespaceURI)
351                        return currInfo;
352        }
353
354        return 0;
355}
356
357inline ValidationContext* SchemaInfo::getValidationContext() const {
358
359        return fValidationContext;
360}
361
362inline bool SchemaInfo::containsInfo(const SchemaInfo* const toCheck,
363                                                                         const ListType aListType) const {
364
365        if ((aListType == INCLUDE) && fIncludeInfoList) {
366                return fIncludeInfoList->containsElement(toCheck);
367        }
368        else if ((aListType == IMPORT) && fImportedInfoList) {
369                return fImportedInfoList->containsElement(toCheck);
370        }
371
372        return false;
373}
374
375inline bool SchemaInfo::circularImportExist(const unsigned int namespaceURI) {
376
377        XMLSize_t importSize = fImportingInfoList->size();
378
379        for (XMLSize_t i=0; i < importSize; i++) {
380                if (fImportingInfoList->elementAt(i)->getTargetNSURI() == (int) namespaceURI) {
381                        return true;
382                }
383        }
384
385        return false;
386}
387
388inline bool SchemaInfo::isFailedRedefine(const DOMElement* const anElem) {
389
390        if (fFailedRedefineList)
391                return (fFailedRedefineList->containsElement(anElem));
392
393        return false;
394}
395
396inline void SchemaInfo::addFailedRedefine(const DOMElement* const anElem) {
397
398        if (!fFailedRedefineList) {
399                fFailedRedefineList = new (fMemoryManager) ValueVectorOf<const DOMElement*>(4, fMemoryManager);
400        }
401
402        fFailedRedefineList->addElement(anElem);
403}
404
405inline void SchemaInfo::clearTopLevelComponents()
406{
407        for (unsigned int i = 0; i < C_Count; i++)
408        {
409
410                delete fTopLevelComponents[i];
411                fTopLevelComponents[i] = 0;
412                fLastTopLevelComponent[i] = 0;
413        }
414}
415
416#ifdef PRINT_DEBUG_MESSAGE
417inline static std::ostream & operator << (std::ostream & out, const SchemaInfo * info)
418{
419        if (!info)
420        {
421                out << "NULL";
422                return out;
423        }
424
425        out << "{SchemaInfo:"
426                << info->getTargetNSURIString()
427                << ',' << info->getCurrentSchemaURL()
428                << ',' << info->getRoot()
429                << ':' << info->getNonXSAttList();
430
431//      BaseRefVectorEnumerator<SchemaInfo> iterator = info->getImportingListEnumerator();
432//      if (iterator.hasMoreElements())
433//      {
434//              out << ",importInfo:" << iterator;
435//      }
436
437        out     << '}';
438
439        return out;
440}
441
442inline static std::ostream & operator << (std::ostream & out, BaseRefVectorEnumerator<SchemaInfo> & iterator)
443{
444        if (iterator.hasMoreElements() && iterator.hasMoreElements())
445        {
446                const SchemaInfo * item = &iterator.nextElement();
447                out << "[SchemaInfoList:" << item;
448                while (iterator.hasMoreElements())
449                {
450                        const SchemaInfo * item = &iterator.nextElement();
451                        out << ',' << item;
452                }
453                out << ']';
454        }
455        return out;
456}
457
458#endif
459
460XERCES_CPP_NAMESPACE_END
461
462#endif
463
464/**
465  * End of file SchemaInfo.hpp
466  */
Note: See TracBrowser for help on using the repository browser.