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

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

Changes to icxercesc files

File size: 7.1 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: AllContentModel.hpp 901107 2010-01-20 08:45:02Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_ALLCONTENTMODEL_HPP)
23#define XERCESC_INCLUDE_GUARD_ALLCONTENTMODEL_HPP
24
25#include <icxercesc/framework/XMLContentModel.hpp>
26#include <xercesc/util/ValueVectorOf.hpp>
27#include <xercesc/validators/common/ContentLeafNameTypeVector.hpp>
28
29XERCES_CPP_NAMESPACE_BEGIN
30
31class ContentSpecNode;
32
33//
34//  AllContentModel is a derivative of the abstract content model base
35//  class that handles the special case of <all> feature in schema. If a model
36//  is <all>, all non-optional children must appear
37//
38//  So, all we have to do is to keep an array of the possible children and
39//  validate by just looking up each child being validated by looking it up
40//  in the list, and make sure all non-optional children appear.
41//
42class AllContentModel : public XMLContentModel
43{
44public :
45        // -----------------------------------------------------------------------
46        //  Constructors and Destructor
47        // -----------------------------------------------------------------------
48        AllContentModel
49        (
50                  ContentSpecNode* const parentContentSpec
51                , const bool             isMixed
52                , MemoryManager* const   manager = XMLPlatformUtils::fgMemoryManager
53        );
54
55        ~AllContentModel();
56
57        // -----------------------------------------------------------------------
58        //  Implementation of the ContentModel virtual interface
59        // -----------------------------------------------------------------------
60
61        virtual bool validateContent
62        (
63                XMLElementDecl ** const                 children
64                , XMLSize_t                                             childCount
65                , XMLSize_t*                                    indexFailingChild
66                , MemoryManager*    const               manager
67        ) const;
68
69        virtual bool validateContentSpecial
70        (
71                XMLElementDecl ** const                 children
72                , XMLSize_t                                             childCount
73                , GrammarResolver*  const               pGrammarResolver
74                , XMLNamespaceResolver* const   pUriResolver
75                , XMLSize_t*                                    indexFailingChild
76                , MemoryManager*    const               manager = XMLPlatformUtils::fgMemoryManager
77        ) const;
78
79        virtual void checkUniqueParticleAttribution
80        (
81                SchemaGrammar*    const pGrammar
82          , GrammarResolver*  const pGrammarResolver
83          , XMLNamespaceResolver* const pUriResolver
84          , XMLValidator*     const pValidator
85          , unsigned int*     const pContentSpecOrgURI
86          , const XMLCh*            pComplexTypeName = 0
87        );
88
89
90        virtual ContentLeafNameTypeVector* getContentLeafNameTypeVector() const ;
91
92        virtual unsigned int getNextState(unsigned int currentState,
93                                                                          XMLSize_t    elementIndex) const;
94
95        virtual bool handleRepetitions( const QName* const curElem,
96                                                                        unsigned int curState,
97                                                                        unsigned int currentLoop,
98                                                                        unsigned int& nextState,
99                                                                        unsigned int& nextLoop,
100                                                                        XMLSize_t elementIndex,
101                                                                        SubstitutionGroupComparator * comparator) const;
102
103        /** @@@ DEPRECATED @@@ **/
104        virtual bool validateContent
105        (
106                QName** const         children
107                , XMLSize_t             childCount
108                , unsigned int          emptyNamespaceId
109                , XMLSize_t*            indexFailingChild
110                , MemoryManager*  const manager = XMLPlatformUtils::fgMemoryManager
111        ) const;
112
113        /** @@@ DEPRECATED @@@ **/
114        virtual bool validateContentSpecial
115        (
116                QName** const           children
117                , XMLSize_t               childCount
118                , unsigned int            emptyNamespaceId
119                , GrammarResolver*  const pGrammarResolver
120                , XMLStringPool*    const pStringPool
121                , XMLSize_t*              indexFailingChild
122                , MemoryManager*    const manager = XMLPlatformUtils::fgMemoryManager
123        ) const;
124
125        /** @@@ DEPRECATED @@@ **/
126        virtual void checkUniqueParticleAttribution
127        (
128                SchemaGrammar*    const pGrammar
129                , GrammarResolver*  const pGrammarResolver
130                , XMLStringPool*    const pStringPool
131                , XMLValidator*     const pValidator
132                , unsigned int*     const pContentSpecOrgURI
133                , const XMLCh*            pComplexTypeName = 0
134        );
135
136
137        #ifdef PRINT_DEBUG_MESSAGE
138        virtual void debug_out(std::ostream & out) const
139        {
140                out << "(AllContentModel: "
141                        << fCount
142                        << ',';
143                if (fCount)
144                {
145                        char leadingChar = '{';
146                        for (XMLSize_t i = 0; i < fCount; i++)
147                        {
148                                out << leadingChar << fChildren[i] << ':' << fChildOptional[i];
149                                leadingChar = ',';
150                        }
151                        out << '}';
152                }
153                out << ',' << fNumRequired
154                        << ',' << fIsMixed
155                        << ',' << fHasOptionalContent
156                        << ')';
157        }
158        #endif
159
160private :
161        // -----------------------------------------------------------------------
162        //  Private helper methods
163        // -----------------------------------------------------------------------
164        void buildChildList
165        (
166                ContentSpecNode* const                     curNode
167          , ValueVectorOf<QName*>&                     toFill
168          , ValueVectorOf<bool>&                       toType
169        );
170
171        // -----------------------------------------------------------------------
172        //  Unimplemented constructors and operators
173        // -----------------------------------------------------------------------
174        AllContentModel();
175        AllContentModel(const AllContentModel&);
176        AllContentModel& operator=(const AllContentModel&);
177
178
179        // -----------------------------------------------------------------------
180        //  Private data members
181        //
182        //  fCount
183        //      The count of possible children in the fChildren member.
184        //
185        //  fChildren
186        //      The list of possible children that we have to accept. This array
187        //      is allocated as large as needed in the constructor.
188        //
189        //  fChildOptional
190        //      The corresponding list of optional state of each child in fChildren
191        //      True if the child is optional (i.e. minOccurs = 0).
192        //
193        //  fNumRequired
194        //      The number of required children in <all> (i.e. minOccurs = 1)
195        //
196        //  fIsMixed
197        //      AllContentModel with mixed PCDATA.
198        // -----------------------------------------------------------------------
199        MemoryManager* fMemoryManager;
200        XMLSize_t       fCount;
201        QName**         fChildren;
202        bool*           fChildOptional;
203        unsigned int    fNumRequired;
204        bool            fIsMixed;
205        bool            fHasOptionalContent;
206};
207
208inline ContentLeafNameTypeVector* AllContentModel::getContentLeafNameTypeVector() const
209{
210        return 0;
211}
212
213inline unsigned int
214AllContentModel::getNextState(unsigned int,
215                                                          XMLSize_t) const {
216
217        return XMLContentModel::gInvalidTrans;
218}
219
220inline bool
221AllContentModel::handleRepetitions( const QName* const /*curElem*/,
222                                                                        unsigned int /*curState*/,
223                                                                        unsigned int /*currentLoop*/,
224                                                                        unsigned int& /*nextState*/,
225                                                                        unsigned int& /*nextLoop*/,
226                                                                        XMLSize_t /*elementIndex*/,
227                                                                        SubstitutionGroupComparator * /*comparator*/) const
228{
229        return true;
230}
231
232XERCES_CPP_NAMESPACE_END
233
234#endif
Note: See TracBrowser for help on using the repository browser.