source: icXML/icXML-devel/src/icxercesc/validators/common/SimpleContentModel.hpp

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

Changes to icxercesc files

File size: 9.6 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: SimpleContentModel.hpp 901107 2010-01-20 08:45:02Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_SIMPLECONTENTMODEL_HPP)
23#define XERCESC_INCLUDE_GUARD_SIMPLECONTENTMODEL_HPP
24
25#include <icxercesc/framework/XMLContentModel.hpp>
26#include <xercesc/validators/common/ContentSpecNode.hpp>
27
28XERCES_CPP_NAMESPACE_BEGIN
29
30//
31//  SimpleContentModel is a derivative of the abstract content model base
32//  class that handles a small set of simple content models that are just
33//  way overkill to give the DFA treatment.
34//
35//  DESCRIPTION:
36//
37//  This guy handles the following scenarios:
38//
39//      a
40//      a?
41//      a*
42//      a+
43//      a,b
44//      a|b
45//
46//  These all involve a unary operation with one element type, or a binary
47//  operation with two elements. These are very simple and can be checked
48//  in a simple way without a DFA and without the overhead of setting up a
49//  DFA for such a simple check.
50//
51//  NOTE:   Pass the XMLElementDecl::fgPCDataElemId value to represent a
52//          PCData node. Pass XMLElementDecl::fgInvalidElemId for unused element
53//
54class SimpleContentModel : public XMLContentModel
55{
56public :
57        // -----------------------------------------------------------------------
58        //  Constructors and Destructor
59        // -----------------------------------------------------------------------
60        SimpleContentModel
61        (
62                const bool                        dtd
63          , QName* const                      firstChild
64          , QName* const                      secondChild
65          , const ContentSpecNode::NodeTypes  cmOp
66          , MemoryManager* const              manager = XMLPlatformUtils::fgMemoryManager
67        );
68
69    SimpleContentModel
70    (
71        const bool                        dtd
72      , QName* const                      firstChild
73      , QName* const                      secondChild
74      , const ContentSpecNode::NodeTypes  cmOp
75      , XMLStringPool* const              qNameManager
76      , MemoryManager* const              manager = XMLPlatformUtils::fgMemoryManager
77    );
78
79        ~SimpleContentModel();
80
81
82        // -----------------------------------------------------------------------
83        //  Implementation of the ContentModel virtual interface
84        // -----------------------------------------------------------------------
85
86        virtual bool validateContent
87        (
88                XMLElementDecl ** const                 children
89                , XMLSize_t                                             childCount
90                , XMLSize_t*                                    indexFailingChild
91                , MemoryManager*    const               manager
92        ) const;
93
94        virtual bool validateContentSpecial
95        (
96                XMLElementDecl ** const                 children
97                , XMLSize_t                                             childCount
98                , GrammarResolver*  const               pGrammarResolver
99                , XMLNamespaceResolver* const   pUriResolver
100                , XMLSize_t*                                    indexFailingChild
101                , MemoryManager*    const               manager = XMLPlatformUtils::fgMemoryManager
102        ) const;
103
104        virtual void checkUniqueParticleAttribution
105        (
106                SchemaGrammar*    const pGrammar
107          , GrammarResolver*  const pGrammarResolver
108          , XMLNamespaceResolver* const pUriResolver
109          , XMLValidator*     const pValidator
110          , unsigned int*     const pContentSpecOrgURI
111          , const XMLCh*            pComplexTypeName = 0
112        );
113
114        /** @@@ DEPRECATED @@@ **/
115        virtual bool validateContent
116        (
117                QName** const         children
118          , XMLSize_t             childCount
119          , unsigned int          emptyNamespaceId
120          , XMLSize_t*            indexFailingChild
121          , MemoryManager*  const manager = XMLPlatformUtils::fgMemoryManager
122        ) const;
123
124        /** @@@ DEPRECATED @@@ **/
125        virtual bool validateContentSpecial
126        (
127                QName** const           children
128          , XMLSize_t               childCount
129          , unsigned int            emptyNamespaceId
130          , GrammarResolver*  const pGrammarResolver
131          , XMLStringPool*    const pStringPool
132          , XMLSize_t*              indexFailingChild
133          , MemoryManager*    const manager = XMLPlatformUtils::fgMemoryManager
134        ) const;
135
136        /** @@@ DEPRECATED @@@ **/
137        virtual void checkUniqueParticleAttribution
138        (
139                SchemaGrammar*    const pGrammar
140          , GrammarResolver*  const pGrammarResolver
141          , XMLStringPool*    const pStringPool
142          , XMLValidator*     const pValidator
143          , unsigned int*     const pContentSpecOrgURI
144          , const XMLCh*            pComplexTypeName = 0
145        );
146
147        virtual ContentLeafNameTypeVector *getContentLeafNameTypeVector() const;
148
149        virtual unsigned int getNextState(unsigned int currentState,
150                                                                          XMLSize_t    elementIndex) const;
151
152        virtual bool handleRepetitions( const QName* const curElem,
153                                                                        unsigned int curState,
154                                                                        unsigned int currentLoop,
155                                                                        unsigned int& nextState,
156                                                                        unsigned int& nextLoop,
157                                                                        XMLSize_t elementIndex,
158                                                                        SubstitutionGroupComparator * comparator) const;
159
160        #ifdef PRINT_DEBUG_MESSAGE
161        virtual void debug_out(std::ostream & out) const
162        {
163                out << "(SimpleContentModel: "
164                        << fFirstChild
165                        << ',' << fSecondChild
166                        << ',' << fOp
167                        << ',' << fDTD
168                        << ')';
169        }
170        #endif
171
172 private :
173        // -----------------------------------------------------------------------
174        //  Unimplemented constructors and operators
175        // -----------------------------------------------------------------------
176        SimpleContentModel();
177        SimpleContentModel(const SimpleContentModel&);
178        SimpleContentModel& operator=(const SimpleContentModel&);
179
180    // -----------------------------------------------------------------------
181    //  Helper routine
182    // -----------------------------------------------------------------------
183
184    static bool equals(bool isDTD, const XMLElementDecl * element, const QName * child);
185
186        // -----------------------------------------------------------------------
187        //  Private data members
188        //
189        //  fFirstChild
190        //  fSecondChild
191        //      The first (and optional second) child node. The
192        //      operation code tells us whether the second child is used or not.
193        //
194        //  fOp
195        //      The operation that this object represents. Since this class only
196        //      does simple contents, there is only ever a single operation
197        //      involved (i.e. the children of the operation are always one or
198        //      two leafs.)
199        //
200        //  fDTD
201        //      Boolean to allow DTDs to validate even with namespace support. */
202        //
203        // -----------------------------------------------------------------------
204        QName*                     fFirstChild;
205        QName*                     fSecondChild;
206        ContentSpecNode::NodeTypes fOp;
207        bool                       fDTD;
208        MemoryManager* const       fMemoryManager;
209};
210
211
212// ---------------------------------------------------------------------------
213//  SimpleContentModel: Constructors and Destructor
214// ---------------------------------------------------------------------------
215inline SimpleContentModel::SimpleContentModel
216(
217      const bool                       dtd
218    , QName* const                     firstChild
219    , QName* const                     secondChild
220    , const ContentSpecNode::NodeTypes cmOp
221     , MemoryManager* const            manager
222)
223    : fFirstChild(firstChild ? new (manager) QName(*firstChild) : 0)
224    , fSecondChild(secondChild ? new (manager) QName(*secondChild) : 0)
225    , fOp(cmOp)
226    , fDTD(dtd)
227    , fMemoryManager(manager)
228{
229
230}
231
232inline SimpleContentModel::SimpleContentModel
233(
234          const bool                       dtd
235        , QName* const                     firstChild
236        , QName* const                     secondChild
237        , const ContentSpecNode::NodeTypes cmOp
238    , XMLStringPool* const             qNameManager
239    , MemoryManager* const             manager
240)
241    : fFirstChild(firstChild ? new (manager) QName(*firstChild) : new (fMemoryManager) QName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, XMLElementDecl::fgInvalidElemId, qNameManager))
242    , fSecondChild(secondChild? new (manager) QName(*secondChild) : new (fMemoryManager) QName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, XMLElementDecl::fgInvalidElemId, qNameManager))
243        , fOp(cmOp)
244        , fDTD(dtd)
245        , fMemoryManager(manager)
246{
247
248}
249
250inline SimpleContentModel::~SimpleContentModel()
251{
252        delete fFirstChild;
253        delete fSecondChild;
254}
255
256inline bool SimpleContentModel::equals(bool isDTD, const XMLElementDecl * element, const QName * child)
257{
258    if (isDTD)
259    {
260        if (unlikely(element->getRawName() != child->getRawName()))
261        {
262            return false;
263        }
264    }
265    else
266    {
267        if (unlikely((element->getLocalPart() != child->getLocalPart()) || (element->getURI() != child->getURI())))
268        {
269            return false;
270        }
271    }
272    return true;
273}
274
275
276// ---------------------------------------------------------------------------
277//  SimpleContentModel: Virtual methods
278// ---------------------------------------------------------------------------
279inline unsigned int
280SimpleContentModel::getNextState(unsigned int,
281                                                                 XMLSize_t) const {
282
283        return XMLContentModel::gInvalidTrans;
284}
285
286inline bool
287SimpleContentModel::handleRepetitions( const QName* const /*curElem*/,
288                                                                           unsigned int /*curState*/,
289                                                                           unsigned int /*currentLoop*/,
290                                                                           unsigned int& /*nextState*/,
291                                                                           unsigned int& /*nextLoop*/,
292                                                                           XMLSize_t /*elementIndex*/,
293                                                                           SubstitutionGroupComparator * /*comparator*/) const
294{
295        return true;
296}
297
298XERCES_CPP_NAMESPACE_END
299
300#endif
Note: See TracBrowser for help on using the repository browser.