source: icXML/icXML-devel/src/icxercesc/validators/common/MixedContentModel.hpp @ 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: 8.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: MixedContentModel.hpp 901107 2010-01-20 08:45:02Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_MIXEDCONTENTMODEL_HPP)
23#define XERCESC_INCLUDE_GUARD_MIXEDCONTENTMODEL_HPP
24
25#include <xercesc/util/ValueVectorOf.hpp>
26#include <xercesc/framework/XMLContentModel.hpp>
27#include <xercesc/validators/common/ContentLeafNameTypeVector.hpp>
28
29XERCES_CPP_NAMESPACE_BEGIN
30
31class ContentSpecNode;
32
33//
34//  MixedContentModel is a derivative of the abstract content model base
35//  class that handles the special case of mixed model elements. If an element
36//  is mixed model, it has PCDATA as its first possible content, followed
37//  by an alternation of the possible children. The children cannot have any
38//  numeration or order, so it must look like this:
39//
40//  <!ELEMENT Foo ((#PCDATA|a|b|c|)*)>
41//
42//  So, all we have to do is to keep an array of the possible children and
43//  validate by just looking up each child being validated by looking it up
44//  in the list.
45//
46class MixedContentModel : public XMLContentModel
47{
48public :
49        // -----------------------------------------------------------------------
50        //  Constructors and Destructor
51        // -----------------------------------------------------------------------
52        MixedContentModel
53        (
54                const bool                dtd
55                , ContentSpecNode* const  parentContentSpec
56                , const bool              ordered = false
57                , MemoryManager* const    manager = XMLPlatformUtils::fgMemoryManager
58        );
59
60        ~MixedContentModel();
61
62
63        // -----------------------------------------------------------------------
64        //  Getter methods
65        // -----------------------------------------------------------------------
66        bool hasDups() const;
67
68        // -----------------------------------------------------------------------
69        //  Implementation of the ContentModel virtual interface
70        // -----------------------------------------------------------------------
71
72        virtual bool validateContent
73        (
74                #ifdef STORE_CHILDREN_INFORMATION_IN_PARSER
75                XMLElementDecl ** const                 children
76                #else
77                QName** const                                   children
78                #endif
79                , XMLSize_t                                             childCount
80                , XMLSize_t*                                    indexFailingChild
81                , MemoryManager*    const               manager
82        ) const;
83
84        virtual bool validateContentSpecial
85        (
86                #ifdef STORE_CHILDREN_INFORMATION_IN_PARSER
87                XMLElementDecl ** const                 children
88                #else
89                QName** const                                   children
90                #endif
91                , XMLSize_t                                             childCount
92                , GrammarResolver*  const               pGrammarResolver
93                , XMLNamespaceResolver* const   pUriResolver
94                , XMLSize_t*                                    indexFailingChild
95                , MemoryManager*    const               manager = XMLPlatformUtils::fgMemoryManager
96        ) const;
97
98        virtual void checkUniqueParticleAttribution
99        (
100                SchemaGrammar*    const pGrammar
101          , GrammarResolver*  const pGrammarResolver
102          , XMLNamespaceResolver* const pUriResolver
103          , XMLValidator*     const pValidator
104          , unsigned int*     const pContentSpecOrgURI
105          , const XMLCh*            pComplexTypeName = 0
106        );
107
108        /** @@@ DEPRECATED @@@ **/
109        virtual bool validateContent
110        (
111                QName** const         children
112          , XMLSize_t             childCount
113          , unsigned int          emptyNamespaceId
114          , XMLSize_t*            indexFailingChild
115          , MemoryManager*  const manager = XMLPlatformUtils::fgMemoryManager
116        ) const;
117
118        /** @@@ DEPRECATED @@@ **/
119        virtual bool validateContentSpecial
120        (
121                QName** const           children
122          , XMLSize_t               childCount
123          , unsigned int            emptyNamespaceId
124          , GrammarResolver*  const pGrammarResolver
125          , XMLStringPool*    const pStringPool
126          , XMLSize_t*              indexFailingChild
127          , MemoryManager*    const manager = XMLPlatformUtils::fgMemoryManager
128        ) const;
129
130        /** @@@ DEPRECATED @@@ **/
131        virtual void checkUniqueParticleAttribution
132        (
133                SchemaGrammar*    const pGrammar
134          , GrammarResolver*  const pGrammarResolver
135          , XMLStringPool*    const pStringPool
136          , XMLValidator*     const pValidator
137          , unsigned int*     const pContentSpecOrgURI
138          , const XMLCh*            pComplexTypeName = 0
139        );
140
141        virtual ContentLeafNameTypeVector* getContentLeafNameTypeVector() const ;
142
143        virtual unsigned int getNextState(unsigned int currentState,
144                                                                          XMLSize_t    elementIndex) const;
145
146        virtual bool handleRepetitions( const QName* const curElem,
147                                                                        unsigned int curState,
148                                                                        unsigned int currentLoop,
149                                                                        unsigned int& nextState,
150                                                                        unsigned int& nextLoop,
151                                                                        XMLSize_t elementIndex,
152                                                                        SubstitutionGroupComparator * comparator) const;
153
154        #ifdef PRINT_DEBUG_MESSAGE
155        virtual void debug_out(std::ostream & out) const
156        {
157                out << "(MixedContentModel: "
158                        << ')';
159        }
160        #endif
161
162private :
163        // -----------------------------------------------------------------------
164        //  Private helper methods
165        // -----------------------------------------------------------------------
166        void buildChildList
167        (
168                ContentSpecNode* const                     curNode
169          , ValueVectorOf<QName*>&                     toFill
170          , ValueVectorOf<ContentSpecNode::NodeTypes>& toType
171        );
172
173        // -----------------------------------------------------------------------
174        //  Unimplemented constructors and operators
175        // -----------------------------------------------------------------------
176        MixedContentModel();
177        MixedContentModel(const MixedContentModel&);
178        MixedContentModel& operator=(const MixedContentModel&);
179
180
181        // -----------------------------------------------------------------------
182        //  Private data members
183        //
184        //  fCount
185        //      The count of possible children in the fChildren member.
186        //
187        //  fChildren
188        //      The list of possible children that we have to accept. This array
189        //      is allocated as large as needed in the constructor.
190        //
191        //  fChildTypes
192        //      The type of the children to support ANY.
193        //
194        //  fOrdered
195        //      True if mixed content model is ordered. DTD mixed content models
196        //      are <em>always</em> unordered.
197        //
198        //  fDTD
199        //      Boolean to allow DTDs to validate even with namespace support.
200        //
201        // -----------------------------------------------------------------------
202        XMLSize_t                   fCount;
203        QName**                     fChildren;
204        ContentSpecNode::NodeTypes* fChildTypes;
205        bool                        fOrdered;
206        bool                        fDTD;
207        MemoryManager*              fMemoryManager;
208};
209
210inline ContentLeafNameTypeVector* MixedContentModel::getContentLeafNameTypeVector() const
211{
212        return 0;
213}
214
215inline unsigned int
216MixedContentModel::getNextState(unsigned int,
217                                                                XMLSize_t) const {
218
219        return XMLContentModel::gInvalidTrans;
220}
221
222inline bool
223MixedContentModel::handleRepetitions( const QName* const /*curElem*/,
224                                                                          unsigned int /*curState*/,
225                                                                          unsigned int /*currentLoop*/,
226                                                                          unsigned int& /*nextState*/,
227                                                                          unsigned int& /*nextLoop*/,
228                                                                          XMLSize_t /*elementIndex*/,
229                                                                          SubstitutionGroupComparator * /*comparator*/) const
230{
231        return true;
232}
233
234inline void MixedContentModel::checkUniqueParticleAttribution
235(
236        SchemaGrammar*    const
237        , GrammarResolver*  const
238#ifndef TEST_NAMESPACE_RESOLVER
239        , XMLStringPool*    const
240#else
241        , XMLNamespaceResolver* const
242#endif
243        , XMLValidator*     const
244        , unsigned int*     const               pContentSpecOrgURI
245        , const XMLCh*
246)
247{
248        // rename back
249        unsigned int i = 0;
250        for (i = 0; i < fCount; i++)
251        {
252                unsigned int orgURIIndex = fChildren[i]->getURI();
253
254                if ((orgURIIndex != XMLContentModel::gEOCFakeId) &&
255                        (orgURIIndex != XMLElementDecl::fgInvalidElemId) &&
256                        (orgURIIndex != XMLElementDecl::fgPCDataElemId))
257                {
258                        fChildren[i]->setURI(pContentSpecOrgURI[orgURIIndex]);
259                }
260        }
261
262        // for mixed content model, it's only a sequence
263        // UPA checking is not necessary
264}
265
266XERCES_CPP_NAMESPACE_END
267
268#endif
Note: See TracBrowser for help on using the repository browser.