307 lines
11 KiB
C++
307 lines
11 KiB
C++
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* $Id: Op.hpp 678879 2008-07-22 20:05:05Z amassari $
|
|
*/
|
|
|
|
#if !defined(XERCESC_INCLUDE_GUARD_OP_HPP)
|
|
#define XERCESC_INCLUDE_GUARD_OP_HPP
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Includes
|
|
// ---------------------------------------------------------------------------
|
|
#include <xercesc/util/RefVectorOf.hpp>
|
|
#include <xercesc/util/RuntimeException.hpp>
|
|
|
|
XERCES_CPP_NAMESPACE_BEGIN
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Forward Declaration
|
|
// ---------------------------------------------------------------------------
|
|
class Token;
|
|
|
|
|
|
class XMLUTIL_EXPORT Op : public XMemory
|
|
{
|
|
public:
|
|
|
|
typedef enum {
|
|
O_DOT = 0,
|
|
O_CHAR = 1,
|
|
O_RANGE = 3,
|
|
O_NRANGE = 4,
|
|
O_ANCHOR = 5,
|
|
O_STRING = 6,
|
|
O_CLOSURE = 7,
|
|
O_NONGREEDYCLOSURE = 8,
|
|
O_FINITE_CLOSURE = 9,
|
|
O_FINITE_NONGREEDYCLOSURE = 10,
|
|
O_QUESTION = 11,
|
|
O_NONGREEDYQUESTION = 12,
|
|
O_UNION = 13,
|
|
O_CAPTURE = 15,
|
|
O_BACKREFERENCE = 16
|
|
} opType;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Public Constructors and Destructor
|
|
// -----------------------------------------------------------------------
|
|
virtual ~Op() { }
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Getter functions
|
|
// -----------------------------------------------------------------------
|
|
opType getOpType() const;
|
|
const Op* getNextOp() const;
|
|
virtual XMLInt32 getData() const;
|
|
virtual XMLInt32 getData2() const;
|
|
virtual XMLSize_t getSize() const;
|
|
virtual const Op* elementAt(XMLSize_t index) const;
|
|
virtual const Op* getChild() const;
|
|
virtual const Token* getToken() const;
|
|
virtual const XMLCh* getLiteral() const;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Setter functions
|
|
// -----------------------------------------------------------------------
|
|
void setOpType(const opType type);
|
|
void setNextOp(const Op* const next);
|
|
|
|
protected:
|
|
// -----------------------------------------------------------------------
|
|
// Protected Constructors
|
|
// -----------------------------------------------------------------------
|
|
Op(const opType type, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
|
|
friend class OpFactory;
|
|
|
|
MemoryManager* const fMemoryManager;
|
|
|
|
private:
|
|
// -----------------------------------------------------------------------
|
|
// Unimplemented constructors and operators
|
|
// -----------------------------------------------------------------------
|
|
Op(const Op&);
|
|
Op& operator=(const Op&);
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Private data members
|
|
//
|
|
// fOpType
|
|
// Indicates the type of operation
|
|
//
|
|
// fNextOp
|
|
// Points to the next operation in the chain
|
|
// -----------------------------------------------------------------------
|
|
opType fOpType;
|
|
const Op* fNextOp;
|
|
};
|
|
|
|
|
|
class XMLUTIL_EXPORT CharOp: public Op {
|
|
public:
|
|
// -----------------------------------------------------------------------
|
|
// Public Constructors and Destructor
|
|
// -----------------------------------------------------------------------
|
|
CharOp(const opType type, const XMLInt32 charData, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
|
|
~CharOp() {}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Getter functions
|
|
// -----------------------------------------------------------------------
|
|
XMLInt32 getData() const;
|
|
|
|
private:
|
|
// Private data members
|
|
XMLInt32 fCharData;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Unimplemented constructors and operators
|
|
// -----------------------------------------------------------------------
|
|
CharOp(const CharOp&);
|
|
CharOp& operator=(const CharOp&);
|
|
};
|
|
|
|
class XMLUTIL_EXPORT UnionOp : public Op {
|
|
public:
|
|
// -----------------------------------------------------------------------
|
|
// Public Constructors and Destructor
|
|
// -----------------------------------------------------------------------
|
|
UnionOp(const opType type, const XMLSize_t size,
|
|
MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
|
|
~UnionOp() { delete fBranches; }
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Getter functions
|
|
// -----------------------------------------------------------------------
|
|
XMLSize_t getSize() const;
|
|
const Op* elementAt(XMLSize_t index) const;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Setter functions
|
|
// -----------------------------------------------------------------------
|
|
void addElement(Op* const op);
|
|
|
|
private:
|
|
// Private Data memebers
|
|
RefVectorOf<Op>* fBranches;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Unimplemented constructors and operators
|
|
// -----------------------------------------------------------------------
|
|
UnionOp(const UnionOp&);
|
|
UnionOp& operator=(const UnionOp&);
|
|
};
|
|
|
|
|
|
class XMLUTIL_EXPORT ChildOp: public Op {
|
|
public:
|
|
// -----------------------------------------------------------------------
|
|
// Public Constructors and Destructor
|
|
// -----------------------------------------------------------------------
|
|
ChildOp(const opType type, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
|
|
~ChildOp() {}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Getter functions
|
|
// -----------------------------------------------------------------------
|
|
const Op* getChild() const;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Setter functions
|
|
// -----------------------------------------------------------------------
|
|
void setChild(const Op* const child);
|
|
|
|
private:
|
|
// Private data members
|
|
const Op* fChild;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Unimplemented constructors and operators
|
|
// -----------------------------------------------------------------------
|
|
ChildOp(const ChildOp&);
|
|
ChildOp& operator=(const ChildOp&);
|
|
};
|
|
|
|
class XMLUTIL_EXPORT ModifierOp: public ChildOp {
|
|
public:
|
|
// -----------------------------------------------------------------------
|
|
// Public Constructors and Destructor
|
|
// -----------------------------------------------------------------------
|
|
ModifierOp(const opType type, const XMLInt32 v1, const XMLInt32 v2, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
|
|
~ModifierOp() {}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Getter functions
|
|
// -----------------------------------------------------------------------
|
|
XMLInt32 getData() const;
|
|
XMLInt32 getData2() const;
|
|
|
|
private:
|
|
// Private data members
|
|
XMLInt32 fVal1;
|
|
XMLInt32 fVal2;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Unimplemented constructors and operators
|
|
// -----------------------------------------------------------------------
|
|
ModifierOp(const ModifierOp&);
|
|
ModifierOp& operator=(const ModifierOp&);
|
|
};
|
|
|
|
class XMLUTIL_EXPORT RangeOp: public Op {
|
|
public:
|
|
// -----------------------------------------------------------------------
|
|
// Public Constructors and Destructor
|
|
// -----------------------------------------------------------------------
|
|
RangeOp(const opType type, const Token* const token, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
|
|
~RangeOp() {}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Getter functions
|
|
// -----------------------------------------------------------------------
|
|
const Token* getToken() const;
|
|
|
|
private:
|
|
// Private data members
|
|
const Token* fToken;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Unimplemented constructors and operators
|
|
// -----------------------------------------------------------------------
|
|
RangeOp(const RangeOp&);
|
|
RangeOp& operator=(const RangeOp&);
|
|
};
|
|
|
|
class XMLUTIL_EXPORT StringOp: public Op {
|
|
public:
|
|
// -----------------------------------------------------------------------
|
|
// Public Constructors and Destructor
|
|
// -----------------------------------------------------------------------
|
|
StringOp(const opType type, const XMLCh* const literal, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
|
|
~StringOp() { fMemoryManager->deallocate(fLiteral);}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Getter functions
|
|
// -----------------------------------------------------------------------
|
|
const XMLCh* getLiteral() const;
|
|
|
|
private:
|
|
// Private data members
|
|
XMLCh* fLiteral;
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Unimplemented constructors and operators
|
|
// -----------------------------------------------------------------------
|
|
StringOp(const StringOp&);
|
|
StringOp& operator=(const StringOp&);
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Op: getter methods
|
|
// ---------------------------------------------------------------------------
|
|
inline Op::opType Op::getOpType() const {
|
|
|
|
return fOpType;
|
|
}
|
|
|
|
inline const Op* Op::getNextOp() const {
|
|
|
|
return fNextOp;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Op: setter methods
|
|
// ---------------------------------------------------------------------------
|
|
inline void Op::setOpType(const Op::opType type) {
|
|
|
|
fOpType = type;
|
|
}
|
|
|
|
inline void Op::setNextOp(const Op* const nextOp) {
|
|
|
|
fNextOp = nextOp;
|
|
}
|
|
|
|
XERCES_CPP_NAMESPACE_END
|
|
|
|
#endif
|
|
|
|
/**
|
|
* End of file Op.hpp
|
|
*/
|