source: icXML/icXML-devel/src/xercesc/validators/schema/identity/XercesXPath.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: 19.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: XercesXPath.hpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_XERCESXPATH_HPP)
23#define XERCESC_INCLUDE_GUARD_XERCESXPATH_HPP
24
25
26// ---------------------------------------------------------------------------
27//  Includes
28// ---------------------------------------------------------------------------
29#include <icxercesc/util/QName.hpp>
30#include <xercesc/util/RefVectorOf.hpp>
31#include <xercesc/util/ValueVectorOf.hpp>
32#include <xercesc/validators/schema/NamespaceScope.hpp>
33#include <xercesc/internal/XSerializable.hpp>
34
35XERCES_CPP_NAMESPACE_BEGIN
36
37// ---------------------------------------------------------------------------
38//  Forward Declarations
39// ---------------------------------------------------------------------------
40class XMLStringPool;
41
42class VALIDATORS_EXPORT XercesNodeTest : public XSerializable, public XMemory
43{
44public:
45    // -----------------------------------------------------------------------
46    //  Constants
47    // -----------------------------------------------------------------------
48    enum NodeType {
49        NodeType_QNAME = 1,
50        NodeType_WILDCARD = 2,
51        NodeType_NODE = 3,
52        NodeType_NAMESPACE= 4,
53        NodeType_UNKNOWN
54    };
55
56    // -----------------------------------------------------------------------
57    //  Constructors/Destructor
58    // -----------------------------------------------------------------------
59    XercesNodeTest(const short type,
60                   MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
61    XercesNodeTest(const QName* const qName);
62    XercesNodeTest(const XMLCh* const prefix, const unsigned int uriId,
63                   MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
64    XercesNodeTest(const XercesNodeTest& other);
65    ~XercesNodeTest() { delete fName; }
66
67    // -----------------------------------------------------------------------
68    //  Operators
69    // -----------------------------------------------------------------------
70    XercesNodeTest& operator= (const XercesNodeTest& other);
71    bool operator== (const XercesNodeTest& other) const;
72    bool operator!= (const XercesNodeTest& other) const;
73
74        // -----------------------------------------------------------------------
75    //  Getter methods
76    // -----------------------------------------------------------------------
77    short getType() const { return fType; }
78    QName* getName() const { return fName; }
79
80    /***
81     * Support for Serialization/De-serialization
82     ***/
83    DECL_XSERIALIZABLE(XercesNodeTest)
84
85    XercesNodeTest(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
86
87private:
88    // -----------------------------------------------------------------------
89    //  Data members
90    // -----------------------------------------------------------------------
91    short  fType;
92    QName* fName;
93};
94
95
96/**
97  * A location path step comprised of an axis and node test.
98  */
99class VALIDATORS_EXPORT XercesStep : public XSerializable, public XMemory
100{
101public:
102    // -----------------------------------------------------------------------
103    //  Constants
104    // -----------------------------------------------------------------------
105    enum AxisType { // Axis type
106        AxisType_CHILD = 1,
107        AxisType_ATTRIBUTE = 2,
108        AxisType_SELF = 3,
109        AxisType_DESCENDANT = 4,
110        AxisType_UNKNOWN
111    };
112
113    // -----------------------------------------------------------------------
114    //  Constructors/Destructor
115    // -----------------------------------------------------------------------
116    XercesStep(const unsigned short axisType, XercesNodeTest* const nodeTest);
117    XercesStep(const XercesStep& other);
118    ~XercesStep() { delete fNodeTest; }
119
120    // -----------------------------------------------------------------------
121    //  Operators
122    // -----------------------------------------------------------------------
123    XercesStep& operator= (const XercesStep& other);
124    bool operator== (const XercesStep& other) const;
125    bool operator!= (const XercesStep& other) const;
126
127        // -----------------------------------------------------------------------
128    //  Getter methods
129    // -----------------------------------------------------------------------
130    unsigned short getAxisType() const { return fAxisType; }
131    XercesNodeTest* getNodeTest() const { return fNodeTest; }
132
133    /***
134     * Support for Serialization/De-serialization
135     ***/
136    DECL_XSERIALIZABLE(XercesStep)
137
138    XercesStep(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
139
140private:
141    // -----------------------------------------------------------------------
142    //  Data members
143    // -----------------------------------------------------------------------
144    unsigned short  fAxisType;
145    XercesNodeTest* fNodeTest;
146};
147
148
149/**
150  * A location path representation for an XPath expression.
151  */
152class VALIDATORS_EXPORT XercesLocationPath : public XSerializable, public XMemory
153{
154public:
155    // -----------------------------------------------------------------------
156    //  Constructors/Destructor
157    // -----------------------------------------------------------------------
158    XercesLocationPath(RefVectorOf<XercesStep>* const steps);
159    ~XercesLocationPath() { delete fSteps; }
160
161    // -----------------------------------------------------------------------
162    //  Operators
163    // -----------------------------------------------------------------------
164    bool operator== (const XercesLocationPath& other) const;
165    bool operator!= (const XercesLocationPath& other) const;
166
167    // -----------------------------------------------------------------------
168    //  Access methods
169    // -----------------------------------------------------------------------
170    XMLSize_t getStepSize() const;
171    void addStep(XercesStep* const aStep);
172    XercesStep* getStep(const XMLSize_t index) const;
173
174    /***
175     * Support for Serialization/De-serialization
176     ***/
177    DECL_XSERIALIZABLE(XercesLocationPath)
178
179    XercesLocationPath(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
180
181private:
182    // -----------------------------------------------------------------------
183    //  Unimplemented constructors and operators
184    // -----------------------------------------------------------------------
185    XercesLocationPath(const XercesLocationPath& other);
186    XercesLocationPath& operator= (const XercesLocationPath& other);
187
188    // -----------------------------------------------------------------------
189    //  Data members
190    // -----------------------------------------------------------------------
191    RefVectorOf<XercesStep>* fSteps;
192};
193
194
195class VALIDATORS_EXPORT XercesXPath : public XSerializable, public XMemory
196{
197public:
198    // -----------------------------------------------------------------------
199    //  Constants
200    // -----------------------------------------------------------------------
201    /**
202      * [28] ExprToken ::= '(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::'
203      *                  | NameTest | NodeType | Operator | FunctionName
204      *                  | AxisName | Literal | Number | VariableReference
205      */
206    enum {
207        EXPRTOKEN_OPEN_PAREN                  =  0,
208        EXPRTOKEN_CLOSE_PAREN                 =  1,
209        EXPRTOKEN_OPEN_BRACKET                =  2,
210        EXPRTOKEN_CLOSE_BRACKET               =  3,
211        EXPRTOKEN_PERIOD                      =  4,
212        EXPRTOKEN_DOUBLE_PERIOD               =  5,
213        EXPRTOKEN_ATSIGN                      =  6,
214        EXPRTOKEN_COMMA                       =  7,
215        EXPRTOKEN_DOUBLE_COLON                =  8,
216        EXPRTOKEN_NAMETEST_ANY                =  9,
217        EXPRTOKEN_NAMETEST_NAMESPACE          = 10,
218        EXPRTOKEN_NAMETEST_QNAME              = 11,
219        EXPRTOKEN_NODETYPE_COMMENT            = 12,
220        EXPRTOKEN_NODETYPE_TEXT               = 13,
221        EXPRTOKEN_NODETYPE_PI                 = 14,
222        EXPRTOKEN_NODETYPE_NODE               = 15,
223        EXPRTOKEN_OPERATOR_AND                = 16,
224        EXPRTOKEN_OPERATOR_OR                 = 17,
225        EXPRTOKEN_OPERATOR_MOD                = 18,
226        EXPRTOKEN_OPERATOR_DIV                = 19,
227        EXPRTOKEN_OPERATOR_MULT               = 20,
228        EXPRTOKEN_OPERATOR_SLASH              = 21,
229        EXPRTOKEN_OPERATOR_DOUBLE_SLASH       = 22,
230        EXPRTOKEN_OPERATOR_UNION              = 23,
231        EXPRTOKEN_OPERATOR_PLUS               = 24,
232        EXPRTOKEN_OPERATOR_MINUS              = 25,
233        EXPRTOKEN_OPERATOR_EQUAL              = 26,
234        EXPRTOKEN_OPERATOR_NOT_EQUAL          = 27,
235        EXPRTOKEN_OPERATOR_LESS               = 28,
236        EXPRTOKEN_OPERATOR_LESS_EQUAL         = 29,
237        EXPRTOKEN_OPERATOR_GREATER            = 30,
238        EXPRTOKEN_OPERATOR_GREATER_EQUAL      = 31,
239        EXPRTOKEN_FUNCTION_NAME               = 32,
240        EXPRTOKEN_AXISNAME_ANCESTOR           = 33,
241        EXPRTOKEN_AXISNAME_ANCESTOR_OR_SELF   = 34,
242        EXPRTOKEN_AXISNAME_ATTRIBUTE          = 35,
243        EXPRTOKEN_AXISNAME_CHILD              = 36,
244        EXPRTOKEN_AXISNAME_DESCENDANT         = 37,
245        EXPRTOKEN_AXISNAME_DESCENDANT_OR_SELF = 38,
246        EXPRTOKEN_AXISNAME_FOLLOWING          = 39,
247        EXPRTOKEN_AXISNAME_FOLLOWING_SIBLING  = 40,
248        EXPRTOKEN_AXISNAME_NAMESPACE          = 41,
249        EXPRTOKEN_AXISNAME_PARENT             = 42,
250        EXPRTOKEN_AXISNAME_PRECEDING          = 43,
251        EXPRTOKEN_AXISNAME_PRECEDING_SIBLING  = 44,
252        EXPRTOKEN_AXISNAME_SELF               = 45,
253        EXPRTOKEN_LITERAL                     = 46,
254        EXPRTOKEN_NUMBER                      = 47,
255        EXPRTOKEN_VARIABLE_REFERENCE          = 48
256    };
257
258    // -----------------------------------------------------------------------
259    //  Constructors/Destructor
260    // -----------------------------------------------------------------------
261    XercesXPath(const XMLCh* const xpathExpr,
262                XMLStringPool* const stringPool,
263                XercesNamespaceResolver* const scopeContext,
264                const unsigned int emptyNamespaceId,
265                const bool isSelector = false,
266                MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
267        ~XercesXPath();
268
269    // -----------------------------------------------------------------------
270    //  Operators
271    // -----------------------------------------------------------------------
272    bool operator== (const XercesXPath& other) const;
273    bool operator!= (const XercesXPath& other) const;
274
275    // -----------------------------------------------------------------------
276    //  Constructors/Destructor
277    // -----------------------------------------------------------------------
278    RefVectorOf<XercesLocationPath>* getLocationPaths() const;
279
280    /***
281     * Support for Serialization/De-serialization
282     ***/
283    DECL_XSERIALIZABLE(XercesXPath)
284
285    XercesXPath(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
286
287    XMLCh* getExpression();
288
289private:
290    // -----------------------------------------------------------------------
291    //  Unimplemented constructors and operators
292    // -----------------------------------------------------------------------
293    XercesXPath(const XercesXPath& other);
294    XercesXPath& operator= (const XercesXPath& other);
295
296    // -----------------------------------------------------------------------
297    //  Helper methods
298    // -----------------------------------------------------------------------
299    void cleanUp();
300    void checkForSelectedAttributes();
301    void parseExpression(XMLStringPool* const stringPool,
302                         XercesNamespaceResolver* const scopeContext);
303
304    // -----------------------------------------------------------------------
305    //  Data members
306    // -----------------------------------------------------------------------
307    unsigned int                     fEmptyNamespaceId;
308    XMLCh*                           fExpression;
309    RefVectorOf<XercesLocationPath>* fLocationPaths;
310    MemoryManager*                   fMemoryManager;
311};
312
313
314class VALIDATORS_EXPORT XPathScanner : public XMemory
315{
316public:
317    // -----------------------------------------------------------------------
318    //  Constants
319    // -----------------------------------------------------------------------
320    enum {
321        CHARTYPE_INVALID            =  0,   // invalid XML character
322        CHARTYPE_OTHER              =  1,   // not special - one of "#%&;?\^`{}~" or DEL
323        CHARTYPE_WHITESPACE         =  2,   // one of "\t\n\r " (0x09, 0x0A, 0x0D, 0x20)
324        CHARTYPE_EXCLAMATION        =  3,   // '!' (0x21)
325        CHARTYPE_QUOTE              =  4,   // '\"' or '\'' (0x22 and 0x27)
326        CHARTYPE_DOLLAR             =  5,   // '$' (0x24)
327        CHARTYPE_OPEN_PAREN         =  6,   // '(' (0x28)
328        CHARTYPE_CLOSE_PAREN        =  7,   // ')' (0x29)
329        CHARTYPE_STAR               =  8,   // '*' (0x2A)
330        CHARTYPE_PLUS               =  9,   // '+' (0x2B)
331        CHARTYPE_COMMA              = 10,   // ',' (0x2C)
332        CHARTYPE_MINUS              = 11,   // '-' (0x2D)
333        CHARTYPE_PERIOD             = 12,   // '.' (0x2E)
334        CHARTYPE_SLASH              = 13,   // '/' (0x2F)
335        CHARTYPE_DIGIT              = 14,   // '0'-'9' (0x30 to 0x39)
336        CHARTYPE_COLON              = 15,   // ':' (0x3A)
337        CHARTYPE_LESS               = 16,   // '<' (0x3C)
338        CHARTYPE_EQUAL              = 17,   // '=' (0x3D)
339        CHARTYPE_GREATER            = 18,   // '>' (0x3E)
340        CHARTYPE_ATSIGN             = 19,   // '@' (0x40)
341        CHARTYPE_LETTER             = 20,   // 'A'-'Z' or 'a'-'z' (0x41 to 0x5A and 0x61 to 0x7A)
342        CHARTYPE_OPEN_BRACKET       = 21,   // '[' (0x5B)
343        CHARTYPE_CLOSE_BRACKET      = 22,   // ']' (0x5D)
344        CHARTYPE_UNDERSCORE         = 23,   // '_' (0x5F)
345        CHARTYPE_UNION              = 24,   // '|' (0x7C)
346        CHARTYPE_NONASCII           = 25   // Non-ASCII Unicode codepoint (>= 0x80)
347    };
348
349    // -----------------------------------------------------------------------
350    //  Constructors/Destructor
351    // -----------------------------------------------------------------------
352    XPathScanner(XMLStringPool* const stringPool);
353    virtual ~XPathScanner() {}
354
355    // -----------------------------------------------------------------------
356    //  Scan methods
357    // -----------------------------------------------------------------------
358    bool scanExpression(const XMLCh* const data, XMLSize_t currentOffset,
359                        const XMLSize_t endOffset, ValueVectorOf<int>* const tokens);
360
361protected:
362    // -----------------------------------------------------------------------
363    //  Helper methods
364    // -----------------------------------------------------------------------
365    /**
366      * This method adds the specified token to the token list. By default,
367      * this method allows all tokens. However, subclasses can can override
368      * this method in order to disallow certain tokens from being used in the
369      * scanned XPath expression. This is a convenient way of allowing only
370      * a subset of XPath.
371      */
372    virtual void addToken(ValueVectorOf<int>* const tokens, const int aToken);
373
374private:
375    // -----------------------------------------------------------------------
376    //  Unimplemented constructors and operators
377    // -----------------------------------------------------------------------
378    XPathScanner(const XPathScanner& other);
379    XPathScanner& operator= (const XPathScanner& other);
380
381    // -----------------------------------------------------------------------
382    //  Helper methods
383    // -----------------------------------------------------------------------
384    void init();
385
386    // -----------------------------------------------------------------------
387    //  Scan methods
388    // -----------------------------------------------------------------------
389    XMLSize_t scanNCName(const XMLCh* const data, const XMLSize_t endOffset,
390                   XMLSize_t currentOffset);
391    XMLSize_t scanNumber(const XMLCh* const data, const XMLSize_t endOffset,
392                   XMLSize_t currentOffset, ValueVectorOf<int>* const tokens);
393
394    // -----------------------------------------------------------------------
395    //  Data members
396    // -----------------------------------------------------------------------
397    int fAndSymbol;
398    int fOrSymbol;
399    int fModSymbol;
400    int fDivSymbol;
401    int fCommentSymbol;
402    int fTextSymbol;
403    int fPISymbol;
404    int fNodeSymbol;
405    int fAncestorSymbol;
406    int fAncestorOrSelfSymbol;
407    int fAttributeSymbol;
408    int fChildSymbol;
409    int fDescendantSymbol;
410    int fDescendantOrSelfSymbol;
411    int fFollowingSymbol;
412    int fFollowingSiblingSymbol;
413    int fNamespaceSymbol;
414    int fParentSymbol;
415    int fPrecedingSymbol;
416    int fPrecedingSiblingSymbol;
417    int fSelfSymbol;
418    XMLStringPool* fStringPool;
419
420    static const XMLByte fASCIICharMap[128];
421};
422
423
424class VALIDATORS_EXPORT XPathScannerForSchema: public XPathScanner
425{
426public:
427    // -----------------------------------------------------------------------
428    //  Constructors/Destructor
429    // -----------------------------------------------------------------------
430    XPathScannerForSchema(XMLStringPool* const stringPool);
431    ~XPathScannerForSchema() {}
432
433protected:
434    // -----------------------------------------------------------------------
435    //  Helper methods
436    // -----------------------------------------------------------------------
437    void addToken(ValueVectorOf<int>* const tokens, const int aToken);
438
439private:
440    // -----------------------------------------------------------------------
441    //  Unimplemented constructors and operators
442    // -----------------------------------------------------------------------
443    XPathScannerForSchema(const XPathScannerForSchema& other);
444    XPathScannerForSchema& operator= (const XPathScannerForSchema& other);
445};
446
447// ---------------------------------------------------------------------------
448//  XercesLocationPath: Access methods
449// ---------------------------------------------------------------------------
450inline XMLSize_t XercesLocationPath::getStepSize() const {
451
452    if (fSteps)
453        return fSteps->size();
454
455    return 0;
456}
457
458inline void XercesLocationPath::addStep(XercesStep* const aStep) {
459
460    fSteps->addElement(aStep);
461}
462
463inline XercesStep* XercesLocationPath::getStep(const XMLSize_t index) const {
464
465    if (fSteps)
466        return fSteps->elementAt(index);
467
468    return 0;
469}
470
471// ---------------------------------------------------------------------------
472//  XercesScanner: Helper methods
473// ---------------------------------------------------------------------------
474inline void XPathScanner::addToken(ValueVectorOf<int>* const tokens,
475                                   const int aToken) {
476    tokens->addElement(aToken);
477}
478
479
480// ---------------------------------------------------------------------------
481//  XercesXPath: Getter methods
482// ---------------------------------------------------------------------------
483inline RefVectorOf<XercesLocationPath>* XercesXPath::getLocationPaths() const {
484
485    return fLocationPaths;
486}
487
488inline XMLCh* XercesXPath::getExpression() {
489    return fExpression;
490}
491
492XERCES_CPP_NAMESPACE_END
493
494#endif
495
496/**
497  * End of file XercesPath.hpp
498  */
499
Note: See TracBrowser for help on using the repository browser.