source: NonGTP/Xerces/xerces/include/xercesc/internal/XTemplateComparator.hpp @ 358

Revision 358, 11.3 KB checked in by bittner, 19 years ago (diff)

xerces added
Line 
1/*
2 * Copyright 2003,2004 The Apache Software Foundation.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/*
18 * $Log: XTemplateComparator.hpp,v $
19 * Revision 1.2  2004/09/08 13:56:14  peiyongz
20 * Apache License Version 2.0
21 *
22 * Revision 1.1  2003/10/29 16:14:15  peiyongz
23 * XObjectComparator/XTemplateComparator
24 *
25 * $Id: XTemplateComparator.hpp,v 1.2 2004/09/08 13:56:14 peiyongz Exp $
26 *
27 */
28
29#if !defined(XTEMPLATE_COMPARATOR_HPP)
30#define XTEMPLATE_COMPARATOR_HPP
31
32#include <xercesc/util/ValueVectorOf.hpp>
33#include <xercesc/util/RefArrayVectorOf.hpp>
34#include <xercesc/util/RefVectorOf.hpp>
35#include <xercesc/util/RefHashTableOf.hpp>
36#include <xercesc/util/RefHash2KeysTableOf.hpp>
37#include <xercesc/util/RefHash3KeysIdPool.hpp>
38#include <xercesc/util/NameIdPool.hpp>
39
40#include <xercesc/framework/XMLNotationDecl.hpp>
41#include <xercesc/framework/XMLRefInfo.hpp>
42#include <xercesc/util/XMLNumber.hpp>
43#include <xercesc/validators/common/ContentSpecNode.hpp>
44#include <xercesc/validators/DTD/DTDAttDef.hpp>
45#include <xercesc/validators/DTD/DTDElementDecl.hpp>
46#include <xercesc/validators/DTD/DTDEntityDecl.hpp>
47#include <xercesc/validators/schema/SchemaAttDef.hpp>
48#include <xercesc/validators/schema/SchemaElementDecl.hpp>
49#include <xercesc/validators/schema/XercesGroupInfo.hpp>
50#include <xercesc/validators/schema/XercesAttGroupInfo.hpp>
51#include <xercesc/validators/schema/SchemaGrammar.hpp>
52#include <xercesc/validators/schema/identity/IC_Field.hpp>
53#include <xercesc/validators/schema/identity/IdentityConstraint.hpp>
54#include <xercesc/validators/schema/identity/XercesXPath.hpp>
55
56XERCES_CPP_NAMESPACE_BEGIN
57
58class XMLUTIL_EXPORT XTemplateComparator
59{
60public:
61
62    /**********************************************************
63     *
64     * ValueVectorOf
65     *
66     *   SchemaElementDecl*
67     *   unsigned int
68     *
69     ***********************************************************/   
70    static bool           isEquivalent(
71                                          ValueVectorOf<SchemaElementDecl*>* const lValue
72                                        , ValueVectorOf<SchemaElementDecl*>* const rValue
73                                       );
74
75    static bool           isEquivalent(
76                                          ValueVectorOf<unsigned int>* const lValue
77                                        , ValueVectorOf<unsigned int>* const rValue
78                                       );
79
80    /**********************************************************
81     *
82     * RefArrayVectorOf
83     *
84     *   XMLCh
85     *
86     ***********************************************************/   
87    static bool           isEquivalent(
88                                          RefArrayVectorOf<XMLCh>* const lValue
89                                        , RefArrayVectorOf<XMLCh>* const rValue
90                                       );
91
92    /**********************************************************
93     *
94     * RefVectorOf
95     *
96     *   SchemaAttDef
97     *   SchemaElementDecl
98     *   ContentSpecNode
99     *   IC_Field
100     *   DatatypeValidator
101     *   IdentityConstraint
102     *   XMLNumber
103     *   XercesLocationPath
104     *   XercesStep
105     *
106     ***********************************************************/
107    static bool           isEquivalent(
108                                          RefVectorOf<SchemaAttDef>* const lValue
109                                        , RefVectorOf<SchemaAttDef>* const rValue
110                                       );
111
112    static bool           isEquivalent(
113                                          RefVectorOf<SchemaElementDecl>* const lValue
114                                        , RefVectorOf<SchemaElementDecl>* const rValue
115                                       );
116
117    static bool           isEquivalent(
118                                          RefVectorOf<ContentSpecNode>* const lValue
119                                        , RefVectorOf<ContentSpecNode>* const rValue
120                                       );
121
122    static bool           isEquivalent(
123                                          RefVectorOf<IC_Field>* const lValue
124                                        , RefVectorOf<IC_Field>* const rValue
125                                       );
126
127    static bool           isEquivalent(
128                                          RefVectorOf<DatatypeValidator>* const lValue
129                                        , RefVectorOf<DatatypeValidator>* const rValue
130                                       );
131
132    static bool           isEquivalent(
133                                          RefVectorOf<IdentityConstraint>* const lValue
134                                        , RefVectorOf<IdentityConstraint>* const rValue
135                                       );
136
137    static bool           isEquivalent(
138                                          RefVectorOf<XMLNumber>* const lValue
139                                        , RefVectorOf<XMLNumber>* const rValue
140                                       );
141
142    static bool           isEquivalent(
143                                          RefVectorOf<XercesLocationPath>* const lValue
144                                        , RefVectorOf<XercesLocationPath>* const rValue
145                                       );
146
147    static bool           isEquivalent(
148                                          RefVectorOf<XercesStep>* const lValue
149                                        , RefVectorOf<XercesStep>* const rValue
150                                       );
151
152    /**********************************************************
153     *
154     * RefHashTableOf
155     *
156     *   KVStringPair
157     *   XMLAttDef
158     *   DTDAttDef
159     *   ComplexTypeInfo
160     *   XercesGroupInfo
161     *   XercesAttGroupInfo
162     *   XMLRefInfo
163     *   DatatypeValidator
164     *   Grammar
165     *
166     ***********************************************************/
167    static bool           isEquivalent(
168                                          RefHashTableOf<KVStringPair>* const lValue
169                                        , RefHashTableOf<KVStringPair>* const rValue
170                                       );
171
172    static bool           isEquivalent(
173                                          RefHashTableOf<XMLAttDef>* const lValue
174                                        , RefHashTableOf<XMLAttDef>* const rValue
175                                       );
176
177    static bool           isEquivalent(
178                                          RefHashTableOf<DTDAttDef>* const lValue
179                                        , RefHashTableOf<DTDAttDef>* const rValue
180                                       );
181
182    static bool           isEquivalent(
183                                          RefHashTableOf<ComplexTypeInfo>* const lValue
184                                        , RefHashTableOf<ComplexTypeInfo>* const rValue
185                                       );
186
187    static bool           isEquivalent(
188                                          RefHashTableOf<XercesGroupInfo>* const lValue
189                                        , RefHashTableOf<XercesGroupInfo>* const rValue
190                                       );
191
192    static bool           isEquivalent(
193                                          RefHashTableOf<XercesAttGroupInfo>* const lValue
194                                        , RefHashTableOf<XercesAttGroupInfo>* const rValue
195                                       );
196
197    static bool           isEquivalent(
198                                          RefHashTableOf<XMLRefInfo>* const lValue
199                                        , RefHashTableOf<XMLRefInfo>* const rValue
200                                       );
201
202    static bool           isEquivalent(
203                                          RefHashTableOf<DatatypeValidator>* const lValue
204                                        , RefHashTableOf<DatatypeValidator>* const rValue
205                                       );
206
207    static bool           isEquivalent(
208                                          RefHashTableOf<Grammar>* const lValue
209                                        , RefHashTableOf<Grammar>* const rValue
210                                       );
211
212    /**********************************************************
213     *
214     * RefHash2KeysTableOf
215     *
216     *   SchemaAttDef
217     *   ElemVector
218     *
219     ***********************************************************/
220    static bool           isEquivalent(
221                                          RefHash2KeysTableOf<SchemaAttDef>* const lValue
222                                        , RefHash2KeysTableOf<SchemaAttDef>* const rValue
223                                       );
224
225    static bool           isEquivalent(
226                                          RefHash2KeysTableOf<ElemVector>* const lValue
227                                        , RefHash2KeysTableOf<ElemVector>* const rValue
228                                       );
229
230    /**********************************************************
231     *
232     * RefHash3KeysIdPool
233     *
234     *   SchemaElementDecl
235     *
236     ***********************************************************/
237    static bool           isEquivalent(
238                                         RefHash3KeysIdPool<SchemaElementDecl>* const lop
239                                       , RefHash3KeysIdPool<SchemaElementDecl>* const rop
240                                      );
241
242
243    /**********************************************************
244     *
245     * NameIdPool
246     *
247     *   DTDElementDecl
248     *   DTDEntityDecl
249     *   XMLNotationDecl
250     *
251     ***********************************************************/
252    static bool           isEquivalent(
253                                          NameIdPool<DTDElementDecl>* const lValue
254                                        , NameIdPool<DTDElementDecl>* const rValue
255                                       );
256
257    static bool           isEquivalent(
258                                          NameIdPool<DTDEntityDecl>* const lValue
259                                        , NameIdPool<DTDEntityDecl>* const rValue
260                                       );
261
262    static bool           isEquivalent(
263                                          NameIdPool<XMLNotationDecl>* const lValue
264                                        , NameIdPool<XMLNotationDecl>* const rValue
265                                       );
266
267private:
268    // -----------------------------------------------------------------------
269    //  Unimplemented constructors and operators
270    // -----------------------------------------------------------------------
271        ~XTemplateComparator();
272    XTemplateComparator();
273    XTemplateComparator(const XTemplateComparator&);
274        XTemplateComparator& operator=(const XTemplateComparator&);
275
276};
277
278XERCES_CPP_NAMESPACE_END
279
280#endif
Note: See TracBrowser for help on using the repository browser.