source: icXML/icXML-devel/src/xercesc/validators/DTD/DTDGrammar.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: 12.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: DTDGrammar.hpp 883368 2009-11-23 15:28:19Z amassari $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_DTDGRAMMAR_HPP)
23#define XERCESC_INCLUDE_GUARD_DTDGRAMMAR_HPP
24
25#include <icxercesc/util/RefHashTableOf.hpp>
26#include <xercesc/util/NameIdPool.hpp>
27#include <xercesc/util/StringPool.hpp>
28#include <xercesc/validators/common/Grammar.hpp>
29#include <icxercesc/validators/DTD/DTDElementDecl.hpp>
30#include <xercesc/validators/DTD/DTDEntityDecl.hpp>
31#include <xercesc/framework/XMLDTDDescription.hpp>
32
33
34XERCES_CPP_NAMESPACE_BEGIN
35
36//
37// This class stores the DTD information
38//  NOTE: DTDs are not namespace aware, so we just use regular NameIdPool
39//  data structures to store element and attribute decls. They are all set
40//  to be in the global namespace and the full QName is used as the base name
41//  of the decl. This means that all the URI parameters below are expected
42//  to be null pointers (and anything else will cause an exception.)
43//
44
45class VALIDATORS_EXPORT DTDGrammar : public Grammar
46{
47public:
48    // -----------------------------------------------------------------------
49    //  Constructors and Destructor
50    // -----------------------------------------------------------------------
51    DTDGrammar(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
52    virtual ~DTDGrammar();
53
54    // -----------------------------------------------------------------------
55    //  Implementation of Virtual Interface
56    // -----------------------------------------------------------------------
57    virtual Grammar::GrammarType getGrammarType() const;
58    virtual const XMLCh* getTargetNamespace() const;
59
60    // this method should only be used while the grammar is being
61    // constructed, not while it is being used
62    // in a validation episode!
63    virtual XMLElementDecl* findOrAddElemDecl
64    (
65        const   unsigned int    uriId
66        , const XMLCh* const    baseName
67        , const XMLCh* const    prefixName
68        , const XMLCh* const    qName
69        , unsigned int          scope
70        ,       bool&           wasAdded
71    ) ;
72
73    virtual XMLSize_t getElemId
74    (
75        const   unsigned int    uriId
76        , const XMLCh* const    baseName
77        , const XMLCh* const    qName
78        , unsigned int          scope
79    )   const ;
80
81    virtual const XMLElementDecl* getElemDecl
82    (
83        const   unsigned int    uriId
84        , const XMLCh* const    baseName
85        , const XMLCh* const    qName
86        , unsigned int          scope
87    )   const ;
88
89    virtual XMLElementDecl* getElemDecl
90    (
91        const   unsigned int    uriId
92        , const XMLCh* const    baseName
93        , const XMLCh* const    qName
94        , unsigned int          scope
95    );
96
97    virtual const XMLElementDecl* getElemDecl
98    (
99        const   unsigned int    elemId
100    )   const;
101
102    virtual XMLElementDecl* getElemDecl
103    (
104        const   unsigned int    elemId
105    );
106
107    virtual const XMLNotationDecl* getNotationDecl
108    (
109        const   XMLCh* const    notName
110    )   const;
111
112    virtual XMLNotationDecl* getNotationDecl
113    (
114        const   XMLCh* const    notName
115    );
116
117    virtual bool getValidated() const;
118
119    virtual XMLElementDecl* putElemDecl
120    (
121        const   unsigned int    uriId
122        , const XMLCh* const    baseName
123        , const XMLCh* const    prefixName
124        , const XMLCh* const    qName
125        , unsigned int          scope
126        , const bool            notDeclared = false
127    );
128
129    virtual XMLSize_t putElemDecl
130    (
131        XMLElementDecl* const elemDecl
132        , const bool          notDeclared = false
133    )   ;
134
135    virtual XMLSize_t putNotationDecl
136    (
137        XMLNotationDecl* const notationDecl
138    )   const;
139
140    virtual void setValidated(const bool newState);
141
142    virtual void reset();
143
144    // -----------------------------------------------------------------------
145    //  Getter methods
146    // -----------------------------------------------------------------------
147
148    const DTDEntityDecl* getEntityDecl(const XMLCh* const entName) const;
149    DTDEntityDecl* getEntityDecl(const XMLCh* const entName);
150    NameIdPool<DTDEntityDecl>* getEntityDeclPool();
151    const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const;
152    NameIdPoolEnumerator<DTDElementDecl> getElemEnumerator() const;
153    NameIdPoolEnumerator<DTDEntityDecl> getEntityEnumerator() const;
154    NameIdPoolEnumerator<XMLNotationDecl> getNotationEnumerator() const;
155
156    // -----------------------------------------------------------------------
157    //  Setter methods
158    // -----------------------------------------------------------------------
159
160    virtual void                    setGrammarDescription( XMLGrammarDescription*);
161    virtual XMLGrammarDescription*  getGrammarDescription() const;
162
163    // -----------------------------------------------------------------------
164    //  Content management methods
165    // -----------------------------------------------------------------------
166    XMLSize_t putEntityDecl(DTDEntityDecl* const entityDecl) const;
167
168    /***
169     * Support for Serialization/De-serialization
170     ***/
171    DECL_XSERIALIZABLE(DTDGrammar)
172
173private:
174    // -----------------------------------------------------------------------
175    // Unimplemented constructors and operators
176    // -----------------------------------------------------------------------
177    DTDGrammar(const DTDGrammar &);
178    DTDGrammar& operator = (const  DTDGrammar&);
179
180    // -----------------------------------------------------------------------
181    //  Private data members
182    //
183    //  fElemDeclPool
184    //      This is the element decl pool. It contains all of the elements
185    //      declared in the DTD (and their associated attributes.)
186    //
187    //  fElemNonDeclPool
188    //      This is the element decl pool that is is populated as new elements
189    //      are seen in the XML document (not declared in the DTD), and they
190    //      are given default characteristics.
191    //
192    //  fEntityDeclPool
193    //      This is a pool of EntityDecl objects, which contains all of the
194    //      general entities that are declared in the DTD subsets, plus the
195    //      default entities (such as &gt; &lt; ...) defined by the XML Standard.
196    //
197    //  fNotationDeclPool
198    //      This is a pool of NotationDecl objects, which contains all of the
199    //      notations declared in the DTD subsets.
200    //
201    //  fValidated
202    //      Indicates if the content of the Grammar has been pre-validated
203    //      or not. When using a cached grammar, no need for pre content
204    //      validation.
205    //
206    //  fGramDesc: adopted
207    //
208    // -----------------------------------------------------------------------
209    static NameIdPool<DTDEntityDecl>* fDefaultEntities;
210    MemoryManager*                    fMemoryManager;
211    NameIdPool<DTDElementDecl>*       fElemDeclPool;
212    NameIdPool<DTDElementDecl>*       fElemNonDeclPool;
213    NameIdPool<DTDEntityDecl>*        fEntityDeclPool;
214    NameIdPool<XMLNotationDecl>*      fNotationDeclPool;
215    XMLDTDDescription*                fGramDesc;
216
217    bool                              fValidated;
218
219    friend class XMLInitializer;
220};
221
222// ---------------------------------------------------------------------------
223//  DTDGrammar: Getter methods
224// ---------------------------------------------------------------------------
225inline NameIdPoolEnumerator<DTDElementDecl>
226DTDGrammar::getElemEnumerator() const
227{
228    return NameIdPoolEnumerator<DTDElementDecl>(fElemDeclPool, fMemoryManager);
229}
230
231inline NameIdPoolEnumerator<DTDEntityDecl>
232DTDGrammar::getEntityEnumerator() const
233{
234    return NameIdPoolEnumerator<DTDEntityDecl>(fEntityDeclPool, fMemoryManager);
235}
236
237inline NameIdPoolEnumerator<XMLNotationDecl>
238DTDGrammar::getNotationEnumerator() const
239{
240    return NameIdPoolEnumerator<XMLNotationDecl>(fNotationDeclPool, fMemoryManager);
241}
242
243inline const DTDEntityDecl*
244DTDGrammar::getEntityDecl(const XMLCh* const entName) const
245{
246    DTDEntityDecl* decl = fDefaultEntities->getByKey(entName);
247
248    if (!decl)
249        return fEntityDeclPool->getByKey(entName);
250
251    return decl;
252}
253
254inline DTDEntityDecl* DTDGrammar::getEntityDecl(const XMLCh* const entName)
255{
256    DTDEntityDecl* decl = fDefaultEntities->getByKey(entName);
257
258    if (!decl)
259        return fEntityDeclPool->getByKey(entName);
260
261    return decl;
262}
263
264
265inline NameIdPool<DTDEntityDecl>* DTDGrammar::getEntityDeclPool()
266{
267    return fEntityDeclPool;
268}
269
270inline const NameIdPool<DTDEntityDecl>* DTDGrammar::getEntityDeclPool() const
271{
272    return fEntityDeclPool;
273}
274
275// -----------------------------------------------------------------------
276//  Setter methods
277// -----------------------------------------------------------------------
278inline XMLSize_t DTDGrammar::putEntityDecl(DTDEntityDecl* const entityDecl)   const
279{
280    return fEntityDeclPool->put(entityDecl);
281}
282
283
284// ---------------------------------------------------------------------------
285//  DTDGrammar: Virtual methods
286// ---------------------------------------------------------------------------
287inline Grammar::GrammarType DTDGrammar::getGrammarType() const {
288    return Grammar::DTDGrammarType;
289}
290
291inline const XMLCh* DTDGrammar::getTargetNamespace() const {
292    return XMLUni::fgZeroLenString;
293}
294
295// Element Decl
296inline XMLSize_t DTDGrammar::getElemId (const   unsigned int
297                                              , const XMLCh* const
298                                              , const XMLCh* const    qName
299                                              , unsigned int) const
300{
301    //
302    //  In this case, we don't return zero to mean 'not found', so we have to
303    //  map it to the official not found value if we don't find it.
304    //
305    const DTDElementDecl* decl = fElemDeclPool->getByKey(qName);
306    if (!decl)
307        return XMLElementDecl::fgInvalidElemId;
308    return decl->getId();
309}
310
311inline const XMLElementDecl* DTDGrammar::getElemDecl( const   unsigned int
312                                              , const XMLCh* const
313                                              , const XMLCh* const    qName
314                                              , unsigned int)   const
315{
316    const XMLElementDecl* elemDecl = fElemDeclPool->getByKey(qName);
317
318    if (!elemDecl && fElemNonDeclPool)
319        elemDecl = fElemNonDeclPool->getByKey(qName);
320
321    return elemDecl;
322}
323
324inline XMLElementDecl* DTDGrammar::getElemDecl (const   unsigned int
325                                              , const XMLCh* const
326                                              , const XMLCh* const    qName
327                                              , unsigned int)
328{
329    XMLElementDecl* elemDecl = fElemDeclPool->getByKey(qName);
330
331    if (!elemDecl && fElemNonDeclPool)
332        elemDecl = fElemNonDeclPool->getByKey(qName);
333
334    return elemDecl;
335}
336
337inline const XMLElementDecl* DTDGrammar::getElemDecl(const unsigned int elemId) const
338{
339    // Look up this element decl by id
340    return fElemDeclPool->getById(elemId);
341}
342
343inline XMLElementDecl* DTDGrammar::getElemDecl(const unsigned int elemId)
344{
345    // Look up this element decl by id
346    return fElemDeclPool->getById(elemId);
347}
348
349inline XMLSize_t
350DTDGrammar::putElemDecl(XMLElementDecl* const elemDecl,
351                        const bool notDeclared)
352{
353    if (notDeclared)
354    {
355        if(!fElemNonDeclPool)
356            fElemNonDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(29, 128, fMemoryManager);
357        return fElemNonDeclPool->put((DTDElementDecl*) elemDecl);
358    }
359
360    return fElemDeclPool->put((DTDElementDecl*) elemDecl);
361}
362
363// Notation Decl
364inline const XMLNotationDecl* DTDGrammar::getNotationDecl(const XMLCh* const notName) const
365{
366    return fNotationDeclPool->getByKey(notName);
367}
368
369inline XMLNotationDecl* DTDGrammar::getNotationDecl(const XMLCh* const notName)
370{
371    return fNotationDeclPool->getByKey(notName);
372}
373
374inline XMLSize_t DTDGrammar::putNotationDecl(XMLNotationDecl* const notationDecl)   const
375{
376    return fNotationDeclPool->put(notationDecl);
377}
378
379inline bool DTDGrammar::getValidated() const
380{
381    return fValidated;
382}
383
384inline void DTDGrammar::setValidated(const bool newState)
385{
386    fValidated = newState;
387}
388
389XERCES_CPP_NAMESPACE_END
390
391#endif
Note: See TracBrowser for help on using the repository browser.