source: icXML/icXML-devel/src/xercesc/validators/schema/SchemaInfo.hpp @ 2722

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

Original Xerces files with import mods for icxercesc

File size: 14.7 KB
RevLine 
[2722]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
46XERCES_CPP_NAMESPACE_BEGIN
47
48// ---------------------------------------------------------------------------
49//  Forward Declarations
50// ---------------------------------------------------------------------------
51class XMLScanner;
52class ValidationContext;
53class NamespaceScope;
54
55class VALIDATORS_EXPORT SchemaInfo : public XMemory
56{
57public:
58
59    enum ListType {
60        // Redefine is treated as an include
61        IMPORT = 1,
62        INCLUDE = 2
63    };
64
65    enum {
66        C_ComplexType,
67        C_SimpleType,
68        C_Group,
69        C_Attribute,
70        C_AttributeGroup,
71        C_Element,
72        C_Notation,
73
74        C_Count
75    };
76
77    // -----------------------------------------------------------------------
78    //  Constructor/Destructor
79    // -----------------------------------------------------------------------
80    SchemaInfo(const unsigned short fElemAttrDefaultQualified,
81               const int blockDefault,
82               const int finalDefault,
83               const int targetNSURI,
84               const NamespaceScope* const currNamespaceScope,
85               const XMLCh* const schemaURL,
86               const XMLCh* const targetNSURIString,
87               const DOMElement* const root,
88               XMLScanner* xmlScanner,
89               MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
90    ~SchemaInfo();
91
92
93    // -----------------------------------------------------------------------
94    //  Getter methods
95    // -----------------------------------------------------------------------
96    XMLCh*                            getCurrentSchemaURL() const;
97    const XMLCh*                      getTargetNSURIString() const;
98    const DOMElement*                 getRoot() const;
99    bool                              getProcessed() const;
100    int                               getBlockDefault() const;
101    int                               getFinalDefault() const;
102    int                               getTargetNSURI() const;
103    NamespaceScope*                   getNamespaceScope() const;
104    unsigned short                    getElemAttrDefaultQualified() const;
105    BaseRefVectorEnumerator<SchemaInfo>   getImportingListEnumerator() const;
106    ValueVectorOf<const DOMElement*>* getRecursingAnonTypes() const;
107    ValueVectorOf<const XMLCh*>*      getRecursingTypeNames() const;
108    ValueVectorOf<DOMNode*>*          getNonXSAttList() const;
109    ValidationContext*                getValidationContext() const;
110
111    // -----------------------------------------------------------------------
112    //  Setter methods
113    // -----------------------------------------------------------------------
114    void setProcessed(const bool aValue = true);
115    void setBlockDefault(const int aValue);
116    void setFinalDefault(const int aValue);
117    void setElemAttrDefaultQualified(const unsigned short aValue);
118    void resetRoot ();
119
120    // -----------------------------------------------------------------------
121    //  Access methods
122    // -----------------------------------------------------------------------
123    void addSchemaInfo(SchemaInfo* const toAdd, const ListType aListType);
124    bool containsInfo(const SchemaInfo* const toCheck, const ListType aListType) const;
125    SchemaInfo* getImportInfo(const unsigned int namespaceURI) const;
126    DOMElement* getTopLevelComponent(const unsigned short compCategory,
127                                     const XMLCh* const compName,
128                                     const XMLCh* const name);
129    DOMElement* getTopLevelComponent(const unsigned short compCategory,
130                                     const XMLCh* const compName,
131                                     const XMLCh* const name,
132                                     SchemaInfo** enclosingSchema);
133    void updateImportingInfo(SchemaInfo* const importingInfo);
134    bool circularImportExist(const unsigned int nameSpaceURI);
135    bool isFailedRedefine(const DOMElement* const anElem);
136    void addFailedRedefine(const DOMElement* const anElem);
137    void addRecursingType(const DOMElement* const elem, const XMLCh* const name);
138
139private:
140    // -----------------------------------------------------------------------
141    //  Unimplemented constructors and operators
142    // -----------------------------------------------------------------------
143    SchemaInfo(const SchemaInfo&);
144    SchemaInfo& operator=(const SchemaInfo&);
145
146    // -----------------------------------------------------------------------
147    //  Private helper methods
148    // -----------------------------------------------------------------------
149    void clearTopLevelComponents();
150
151    // -----------------------------------------------------------------------
152    //  Private data members
153    // -----------------------------------------------------------------------
154    bool                              fAdoptInclude;
155    bool                              fProcessed;
156    unsigned short                    fElemAttrDefaultQualified;
157    int                               fBlockDefault;
158    int                               fFinalDefault;
159    int                               fTargetNSURI;
160    NamespaceScope*                   fNamespaceScope;
161    XMLCh*                            fCurrentSchemaURL;
162    XMLCh*                            fTargetNSURIString;
163    const DOMElement*                 fSchemaRootElement;
164    RefVectorOf<SchemaInfo>*          fIncludeInfoList;
165    RefVectorOf<SchemaInfo>*          fImportedInfoList;
166    RefVectorOf<SchemaInfo>*          fImportingInfoList;
167    ValueVectorOf<const DOMElement*>* fFailedRedefineList;
168    ValueVectorOf<const DOMElement*>* fRecursingAnonTypes;
169    ValueVectorOf<const XMLCh*>*      fRecursingTypeNames;
170    RefHashTableOf<DOMElement>*       fTopLevelComponents[C_Count];
171    DOMElement*                       fLastTopLevelComponent[C_Count];
172    ValueVectorOf<DOMNode*>*          fNonXSAttList;
173    ValidationContext*                fValidationContext;
174    MemoryManager*                    fMemoryManager;
175};
176
177// ---------------------------------------------------------------------------
178//  SchemaInfo: Getter methods
179// ---------------------------------------------------------------------------
180inline unsigned short SchemaInfo::getElemAttrDefaultQualified() const {
181
182    return fElemAttrDefaultQualified;
183}
184
185inline bool SchemaInfo::getProcessed() const {
186
187    return fProcessed;
188}
189
190inline int SchemaInfo::getBlockDefault() const {
191
192    return fBlockDefault;
193}
194
195inline int SchemaInfo::getFinalDefault() const {
196
197    return fFinalDefault;
198}
199
200inline NamespaceScope* SchemaInfo::getNamespaceScope() const {
201    return fNamespaceScope;
202}
203
204inline XMLCh* SchemaInfo::getCurrentSchemaURL() const {
205
206    return fCurrentSchemaURL;
207}
208
209inline const XMLCh* SchemaInfo::getTargetNSURIString() const {
210
211    return fTargetNSURIString;
212}
213
214inline const DOMElement* SchemaInfo::getRoot() const {
215
216    return fSchemaRootElement;
217}
218
219inline int SchemaInfo::getTargetNSURI() const {
220
221    return fTargetNSURI;
222}
223
224inline BaseRefVectorEnumerator<SchemaInfo>
225SchemaInfo::getImportingListEnumerator() const {
226
227    return BaseRefVectorEnumerator<SchemaInfo>(fImportingInfoList);
228}
229
230inline ValueVectorOf<const DOMElement*>*
231SchemaInfo::getRecursingAnonTypes() const {
232
233    return fRecursingAnonTypes;
234}
235
236
237inline ValueVectorOf<const XMLCh*>*
238SchemaInfo::getRecursingTypeNames() const {
239
240    return fRecursingTypeNames;
241}
242
243inline ValueVectorOf<DOMNode*>* SchemaInfo::getNonXSAttList() const
244{
245    return fNonXSAttList;
246}
247
248// ---------------------------------------------------------------------------
249//  Setter methods
250// ---------------------------------------------------------------------------
251inline void SchemaInfo::setBlockDefault(const int aValue) {
252
253    fBlockDefault = aValue;
254}
255
256inline void SchemaInfo::setFinalDefault(const int aValue) {
257
258    fFinalDefault = aValue;
259}
260
261inline void SchemaInfo::setElemAttrDefaultQualified(const unsigned short aValue) {
262
263    fElemAttrDefaultQualified = aValue;
264}
265
266inline void SchemaInfo::setProcessed(const bool aValue) {
267
268    fProcessed = aValue;
269
270/*    if (fProcessed && fIncludeInfoList) {
271
272        unsigned int includeListLen = fIncludeInfoList->size());
273        for (unsigned int i = 0; i < includeListLen; i++) {
274            fIncludeInfoList->elementAt(i)->clearTopLevelComponents();
275        }
276    }*/
277}
278
279inline void SchemaInfo::resetRoot ()
280{
281    fSchemaRootElement = 0;
282}
283
284// ---------------------------------------------------------------------------
285//  SchemaInfo: Access methods
286// ---------------------------------------------------------------------------
287inline void SchemaInfo::addSchemaInfo(SchemaInfo* const toAdd,
288                                      const ListType aListType) {
289
290    if (aListType == IMPORT) {
291
292        if (!fImportedInfoList)
293            fImportedInfoList = new (fMemoryManager) RefVectorOf<SchemaInfo>(4, false, fMemoryManager);
294
295        if (!fImportedInfoList->containsElement(toAdd)) {
296
297            fImportedInfoList->addElement(toAdd);
298            toAdd->updateImportingInfo(this);
299        }
300    }
301    else {
302
303        if (!fIncludeInfoList) {
304
305            fIncludeInfoList = new (fMemoryManager) RefVectorOf<SchemaInfo>(8, false, fMemoryManager);
306            fAdoptInclude = true;
307        }
308
309        if (!fIncludeInfoList->containsElement(toAdd)) {
310
311                    fIncludeInfoList->addElement(toAdd);
312            //code was originally:
313            //toAdd->fIncludeInfoList = fIncludeInfoList;
314            //however for handling multiple imports this was causing
315            //to schemaInfo's to have the same fIncludeInfoList which they
316            //both owned so when it was deleted it crashed.
317                        if (toAdd->fIncludeInfoList) {
318                           if (toAdd->fIncludeInfoList != fIncludeInfoList) {
319                   XMLSize_t size = toAdd->fIncludeInfoList->size();
320                   for (XMLSize_t i=0; i<size; i++) {
321                       if (!fIncludeInfoList->containsElement(toAdd->fIncludeInfoList->elementAt(i))) {
322                            fIncludeInfoList->addElement(toAdd->fIncludeInfoList->elementAt(i));
323                       }
324                   }
325                   size = fIncludeInfoList->size();
326                   for (XMLSize_t j=0; j<size; j++) {
327                       if (!toAdd->fIncludeInfoList->containsElement(fIncludeInfoList->elementAt(j))) {
328                            toAdd->fIncludeInfoList->addElement(fIncludeInfoList->elementAt(j));
329                       }
330                   }
331                           }
332                        }
333                        else {
334                                toAdd->fIncludeInfoList = fIncludeInfoList;
335                        }
336        }
337    }
338}
339
340inline SchemaInfo* SchemaInfo::getImportInfo(const unsigned int namespaceURI) const {
341
342    XMLSize_t importSize = (fImportedInfoList) ? fImportedInfoList->size() : 0;
343    SchemaInfo* currInfo = 0;
344
345    for (XMLSize_t i=0; i < importSize; i++) {
346
347        currInfo = fImportedInfoList->elementAt(i);
348
349        if (currInfo->getTargetNSURI() == (int) namespaceURI)
350            return currInfo;
351    }
352
353    return 0;
354}
355
356inline ValidationContext* SchemaInfo::getValidationContext() const {
357
358    return fValidationContext;
359}
360
361inline bool SchemaInfo::containsInfo(const SchemaInfo* const toCheck,
362                                     const ListType aListType) const {
363
364    if ((aListType == INCLUDE) && fIncludeInfoList) {
365        return fIncludeInfoList->containsElement(toCheck);
366    }
367    else if ((aListType == IMPORT) && fImportedInfoList) {
368        return fImportedInfoList->containsElement(toCheck);
369    }
370
371    return false;
372}
373
374inline bool SchemaInfo::circularImportExist(const unsigned int namespaceURI) {
375
376    XMLSize_t importSize = fImportingInfoList->size();
377
378    for (XMLSize_t i=0; i < importSize; i++) {
379        if (fImportingInfoList->elementAt(i)->getTargetNSURI() == (int) namespaceURI) {
380            return true;
381        }
382    }
383
384    return false;
385}
386
387inline bool SchemaInfo::isFailedRedefine(const DOMElement* const anElem) {
388
389    if (fFailedRedefineList)
390        return (fFailedRedefineList->containsElement(anElem));
391
392    return false;
393}
394
395inline void SchemaInfo::addFailedRedefine(const DOMElement* const anElem) {
396
397    if (!fFailedRedefineList) {
398        fFailedRedefineList = new (fMemoryManager) ValueVectorOf<const DOMElement*>(4, fMemoryManager);
399    }
400
401    fFailedRedefineList->addElement(anElem);
402}
403
404inline void SchemaInfo::addRecursingType(const DOMElement* const elem,
405                                         const XMLCh* const name) {
406
407    if (!fRecursingAnonTypes) {
408        fRecursingAnonTypes = new (fMemoryManager) ValueVectorOf<const DOMElement*>(8, fMemoryManager);
409        fRecursingTypeNames = new (fMemoryManager) ValueVectorOf<const XMLCh*>(8, fMemoryManager);
410    }
411
412    fRecursingAnonTypes->addElement(elem);
413    fRecursingTypeNames->addElement(name);
414}
415
416inline void SchemaInfo::clearTopLevelComponents() {
417
418    for (unsigned int i = 0; i < C_Count; i++) {
419
420        delete fTopLevelComponents[i];
421        fTopLevelComponents[i] = 0;
422        fLastTopLevelComponent[i] = 0;
423    }
424}
425
426XERCES_CPP_NAMESPACE_END
427
428#endif
429
430/**
431  * End of file SchemaInfo.hpp
432  */
Note: See TracBrowser for help on using the repository browser.