source: icXML/icXML-devel/src/icxercesc/internal/ValidationContextImpl.cpp @ 2720

Last change on this file since 2720 was 2720, checked in by cameron, 7 years ago

Initial check-in of icXML 0.8 source files

File size: 5.2 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: ValidationContextImpl.cpp 903149 2010-01-26 09:58:40Z borisk $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include <xercesc/internal/ValidationContextImpl.hpp>
27#include <xercesc/framework/XMLRefInfo.hpp>
28#include <xercesc/validators/DTD/DTDEntityDecl.hpp>
29#include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
30#include <xercesc/validators/schema/NamespaceScope.hpp>
31#include <xercesc/internal/ElemStack.hpp>
32#include <xercesc/internal/XMLScanner.hpp>
33
34XERCES_CPP_NAMESPACE_BEGIN
35
36// ---------------------------------------------------------------------------
37//  Constructor and Destructor
38// ---------------------------------------------------------------------------
39
40ValidationContextImpl::~ValidationContextImpl()
41{
42        if (fIdRefList)
43                delete fIdRefList;
44}
45
46ValidationContextImpl::ValidationContextImpl(MemoryManager* const manager)
47:ValidationContext(manager)
48,fIdRefList(0)
49,fEntityDeclPool(0)
50,fToCheckIdRefList(true)
51,fValidatingMemberType(0)
52,fScanner(0)
53,fNamespaceScope(0)
54{
55        fIdRefList = new (fMemoryManager) RefHashTableOf<XMLRefInfo>(109, fMemoryManager);
56}
57
58/**
59 * IdRefList
60 *
61 */
62RefHashTableOf<XMLRefInfo>* ValidationContextImpl::getIdRefList() const
63{
64        return fIdRefList;
65}
66
67void ValidationContextImpl::setIdRefList(RefHashTableOf<XMLRefInfo>* const newIdRefList)
68{
69        if (fIdRefList)
70                delete fIdRefList;
71
72        fIdRefList = newIdRefList;
73}
74
75void ValidationContextImpl::clearIdRefList()
76{
77        if (fIdRefList)
78                fIdRefList->removeAll();
79
80}
81
82void ValidationContextImpl::addId(const XMLCh * const content)
83{
84        if (!fIdRefList || !fToCheckIdRefList)
85                return;
86
87        XMLRefInfo* idEntry = fIdRefList->get(content);
88
89        if (idEntry)
90        {
91                if (idEntry->getDeclared())
92                {
93                        ThrowXMLwithMemMgr1(InvalidDatatypeValueException
94                                        , XMLExcepts::VALUE_ID_Not_Unique
95                                        , content
96                                        , fMemoryManager);
97                }
98        }
99        else
100        {
101                idEntry = new (fMemoryManager) XMLRefInfo(content, false, false, fMemoryManager);
102                fIdRefList->put((void*)idEntry->getRefName(), idEntry);
103        }
104
105        //
106        //  Mark it declared
107        //
108        idEntry->setDeclared(true);
109
110}
111
112void ValidationContextImpl::addIdRef(const XMLCh * const content)
113{
114        if (!fIdRefList || !fToCheckIdRefList)
115                return;
116
117        XMLRefInfo* idEntry = fIdRefList->get(content);
118
119        if (!idEntry)
120        {
121                idEntry = new (fMemoryManager) XMLRefInfo(content, false, false, fMemoryManager);
122                fIdRefList->put((void*)idEntry->getRefName(), idEntry);
123        }
124
125        //
126        //  Mark it used
127        //
128        idEntry->setUsed(true);
129
130}
131
132void ValidationContextImpl::toCheckIdRefList(bool toCheck)
133{
134        fToCheckIdRefList = toCheck;
135}
136
137/**
138 * EntityDeclPool
139 *
140 */
141const NameIdPool<DTDEntityDecl>* ValidationContextImpl::getEntityDeclPool() const
142{
143        return fEntityDeclPool;
144}
145
146const NameIdPool<DTDEntityDecl>* ValidationContextImpl::setEntityDeclPool(const NameIdPool<DTDEntityDecl>* const newEntityDeclPool)
147{
148        // we don't own it so we return the existing one for the owner to delete
149        const NameIdPool<DTDEntityDecl>* tempPool = fEntityDeclPool;
150        fEntityDeclPool = newEntityDeclPool;
151        return tempPool;
152
153}
154
155void ValidationContextImpl::checkEntity(const XMLCh * const content) const
156{
157
158        if (fEntityDeclPool)
159        {
160                const DTDEntityDecl* decl = fEntityDeclPool->getByKey(content);
161
162                if (!decl || !decl->isUnparsed())
163                {
164                        ThrowXMLwithMemMgr1(InvalidDatatypeValueException
165                                        , XMLExcepts::VALUE_ENTITY_Invalid
166                                        , content
167                                        , fMemoryManager);
168                }
169
170        }
171        else
172        {
173                ThrowXMLwithMemMgr1
174                (
175                        InvalidDatatypeValueException
176                        , XMLExcepts::VALUE_ENTITY_Invalid
177                        , content
178                        , fMemoryManager
179                );
180        }
181
182}
183
184/* QName
185 */
186bool ValidationContextImpl::isPrefixUnknown(XMLCh* prefix)
187{
188        bool unknown = false;
189
190        if (XMLString::equals(prefix, XMLUni::fgXMLNSString))
191        {
192                return true;
193        }
194        else if (!XMLString::equals(prefix, XMLUni::fgXMLString))
195        {
196                if (fNamespaceScope)
197                {
198                        unknown = (fNamespaceScope->getNamespaceForPrefix(prefix) == fNamespaceScope->getEmptyNamespaceId());
199                }
200                else
201                {
202                        unknown = !fScanner->isPrefixKnown(prefix);
203                }
204        }
205
206        return unknown;
207}
208
209const XMLCh* ValidationContextImpl::getURIForPrefix(XMLCh* prefix)
210{
211        if (fNamespaceScope)
212        {
213                unsigned int uriId = fNamespaceScope->getNamespaceForPrefix(prefix);
214                if (uriId != fNamespaceScope->getEmptyNamespaceId())
215                {
216                        return fScanner->getURIText(uriId);
217                }
218                return XMLUni::fgZeroLenString;
219        }
220        else
221        {
222                return fScanner->getURIForPrefix(prefix);
223        }
224
225}
226
227XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.