source: icXML/icXML-devel/src/icxercesc/validators/schema/SchemaInfo.cpp

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

Changes to icxercesc files

File size: 7.7 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.cpp 925236 2010-03-19 14:29:47Z borisk $
20 */
21
22// ---------------------------------------------------------------------------
23//  Includes
24// ---------------------------------------------------------------------------
25#include <icxercesc/validators/schema/SchemaInfo.hpp>
26#include <xercesc/validators/schema/XUtil.hpp>
27#include <icxercesc/validators/schema/SchemaSymbols.hpp>
28#include <icxercesc/validators/schema/NamespaceScope.hpp>
29#include <xercesc/validators/schema/SchemaValidationContextImpl.hpp>
30#include <icxercesc/util/XMLString.hpp>
31
32
33XERCES_CPP_NAMESPACE_BEGIN
34
35// ---------------------------------------------------------------------------
36//  SchemaInfo: Constructors and Destructor
37// ---------------------------------------------------------------------------
38SchemaInfo::SchemaInfo
39(
40    const unsigned short            elemAttrDefaultQualified
41    , const int                     blockDefault
42    , const int                     finalDefault
43    , const int                     targetNSURI
44    , const NamespaceScope* const   currNamespaceScope
45    , const XMLCh* const            schemaURL
46    , const XMLCh* const            targetNSURIString
47    , const DOMElement* const       root
48    , XMLScanner*                   xmlScanner
49    , MemoryManager* const          manager
50)
51        : fAdoptInclude(false)
52        , fProcessed(false)
53        , fElemAttrDefaultQualified(elemAttrDefaultQualified)
54        , fBlockDefault(blockDefault)
55        , fFinalDefault(finalDefault)
56        , fTargetNSURI(targetNSURI)
57        , fNamespaceScope(0)
58        , fSchemaRootElement(root)
59        , fIncludeInfoList(0)
60        , fImportedInfoList(0)
61        , fImportingInfoList(0)
62        , fFailedRedefineList(0)
63        , fRecursingAnonTypes(0)
64        , fRecursingTypeNames(0)
65        , fNonXSAttList(0)
66        , fValidationContext(0)
67        , fMemoryManager(manager)
68{
69        fImportingInfoList = new (fMemoryManager) RefVectorOf<SchemaInfo>(4, false, fMemoryManager);
70
71        memset(fTopLevelComponents, 0, sizeof(fTopLevelComponents[0]) * C_Count);
72
73        memset(fLastTopLevelComponent, 0, sizeof(fLastTopLevelComponent[0]) * C_Count);
74
75        fNonXSAttList = new (fMemoryManager) ValueVectorOf<DOMNode*>(2, fMemoryManager);
76    fNamespaceScope = new (fMemoryManager) NamespaceScope(currNamespaceScope, fMemoryManager);
77    fValidationContext = new (fMemoryManager) SchemaValidationContextImpl(xmlScanner, fNamespaceScope, fMemoryManager);
78        fCurrentSchemaURL = XMLString::replicate(schemaURL, fMemoryManager);
79        fTargetNSURIString = XMLString::replicate(targetNSURIString, fMemoryManager);
80}
81
82
83SchemaInfo::~SchemaInfo()
84{
85        fMemoryManager->deallocate(fCurrentSchemaURL);//delete [] fCurrentSchemaURL;
86        fMemoryManager->deallocate(fTargetNSURIString);
87        delete fImportedInfoList;
88
89        if (fAdoptInclude)
90                delete fIncludeInfoList;
91
92        delete fImportingInfoList;
93        delete fFailedRedefineList;
94        delete fRecursingAnonTypes;
95        delete fRecursingTypeNames;
96
97    for (unsigned int i = 0; i < C_Count; i++)
98    {
99                delete fTopLevelComponents[i];
100        }
101
102        delete fNonXSAttList;
103        delete fValidationContext;
104        delete fNamespaceScope;
105}
106
107// ---------------------------------------------------------------------------
108//  SchemaInfo:
109// ---------------------------------------------------------------------------
110DOMElement*
111SchemaInfo::getTopLevelComponent(const unsigned short compCategory,
112                                                                 const XMLCh* const compName,
113                                                                 const XMLCh* const name,
114                                                                 SchemaInfo** enclosingSchema) {
115
116        if (fSchemaRootElement == 0)
117          return 0;
118
119        SchemaInfo* currentInfo = this;
120        DOMElement* child = getTopLevelComponent(compCategory, compName, name);
121
122    if (child == 0 && fIncludeInfoList)
123        {
124        XMLSize_t listSize = fIncludeInfoList->size();
125
126                for (XMLSize_t i=0; i < listSize; i++) {
127
128                        currentInfo = fIncludeInfoList->elementAt(i);
129
130                        if (currentInfo == this)
131                                continue;
132
133                        child = currentInfo->getTopLevelComponent(compCategory, compName, name);
134
135                        if (child != 0) {
136
137                                *enclosingSchema = currentInfo;
138                                break;
139                        }
140                }
141        }
142
143        return child;
144}
145
146
147DOMElement*
148SchemaInfo::getTopLevelComponent(const unsigned short compCategory,
149                                                                 const XMLCh* const compName,
150                                                                 const XMLCh* const name) {
151
152        if (fSchemaRootElement == 0 || compCategory >= C_Count)
153          return 0;
154
155        DOMElement* child = XUtil::getFirstChildElement(fSchemaRootElement);
156
157        if (!child)
158                return 0;
159
160        RefHashTableOf<DOMElement>* compList = fTopLevelComponents[compCategory];
161
162        if (fTopLevelComponents[compCategory] == 0) {
163
164                compList= new (fMemoryManager) RefHashTableOf<DOMElement>(17, false, fMemoryManager);
165                fTopLevelComponents[compCategory] = compList;
166        }
167        else {
168                DOMElement* cachedChild = compList->get(name);
169                if(cachedChild)
170                        return cachedChild;
171
172                child = fLastTopLevelComponent[compCategory];
173        }
174
175        DOMElement* redefParent = (DOMElement*) child->getParentNode();
176
177        // Parent is not "redefine"
178        if (!XMLString::equals(redefParent->getLocalName(),SchemaSymbols::fgELT_REDEFINE))
179                redefParent = 0;
180
181        while (child != 0) {
182
183                fLastTopLevelComponent[compCategory]=child;
184                if (XMLString::equals(child->getLocalName(), compName)) {
185
186                        const XMLCh* cName=child->getAttribute(SchemaSymbols::fgATT_NAME);
187                        compList->put((void*)cName, child);
188
189                        if (XMLString::equals(cName, name))
190                                return child;
191                }
192                else if (XMLString::equals(child->getLocalName(),SchemaSymbols::fgELT_REDEFINE)
193                                 && (!fFailedRedefineList || !fFailedRedefineList->containsElement(child))) { // if redefine
194
195                        DOMElement* redefineChild = XUtil::getFirstChildElement(child);
196
197                        while (redefineChild != 0) {
198
199                                fLastTopLevelComponent[compCategory]=redefineChild;
200                                if ((!fFailedRedefineList || !fFailedRedefineList->containsElement(redefineChild))
201                                        && XMLString::equals(redefineChild->getLocalName(), compName)) {
202
203                                        const XMLCh* rName=redefineChild->getAttribute(SchemaSymbols::fgATT_NAME);
204                                        compList->put((void*)rName, redefineChild);
205
206                                        if (XMLString::equals(rName, name))
207                                                return redefineChild;
208                                }
209
210                                redefineChild = XUtil::getNextSiblingElement(redefineChild);
211                        }
212                }
213
214                child = XUtil::getNextSiblingElement(child);
215
216                if (child == 0 && redefParent) {
217
218                        child = XUtil::getNextSiblingElement(redefParent);
219                        redefParent = 0;
220                }
221        }
222
223        return child;
224}
225
226void SchemaInfo::updateImportingInfo(SchemaInfo* const importingInfo) {
227
228        if (!fImportingInfoList->containsElement(importingInfo)) {
229                fImportingInfoList->addElement(importingInfo);
230        }
231
232        XMLSize_t listSize = importingInfo->fImportingInfoList->size();
233
234        for (XMLSize_t i=0; i < listSize; i++) {
235
236                SchemaInfo* tmpInfo = importingInfo->fImportingInfoList->elementAt(i);
237
238                if (tmpInfo != this && !fImportingInfoList->containsElement(tmpInfo)) {
239                        fImportingInfoList->addElement(tmpInfo);
240                }
241        }
242}
243
244void SchemaInfo::addRecursingType(const DOMElement* const elem, const XMLCh* const name)
245{
246
247    if (!fRecursingAnonTypes) {
248        fRecursingAnonTypes = new (fMemoryManager) ValueVectorOf<const DOMElement*>(8, fMemoryManager);
249        fRecursingTypeNames = new (fMemoryManager) ValueVectorOf<const XMLCh*>(8, fMemoryManager);
250    }
251
252    fRecursingAnonTypes->addElement(elem);
253    fRecursingTypeNames->addElement(name);
254}
255
256XERCES_CPP_NAMESPACE_END
257
258/**
259  * End of file SchemaInfo.cpp
260  */
Note: See TracBrowser for help on using the repository browser.