221 lines
7.7 KiB
C++
221 lines
7.7 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtXmlPatterns module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
//
|
|
// W A R N I N G
|
|
// -------------
|
|
//
|
|
// This file is not part of the Qt API. It exists purely as an
|
|
// implementation detail. This header file may change from version to
|
|
// version without notice, or even be removed.
|
|
//
|
|
// We mean it.
|
|
|
|
#ifndef Patternist_OptimizerBlocks_H
|
|
#define Patternist_OptimizerBlocks_H
|
|
|
|
#include <private/qatomiccomparator_p.h>
|
|
#include <private/qexpression_p.h>
|
|
#include <private/qoptimizerframework_p.h>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
namespace QPatternist
|
|
{
|
|
/**
|
|
* @short Identifies Expression instances by their Expression::id().
|
|
*
|
|
* @author Frans englich <frans.englich@nokia.com>
|
|
* @ingroup Patternist_expressions
|
|
*/
|
|
class ByIDIdentifier : public ExpressionIdentifier
|
|
{
|
|
public:
|
|
ByIDIdentifier(const Expression::ID id);
|
|
virtual bool matches(const Expression::Ptr &expr) const;
|
|
private:
|
|
const Expression::ID m_id;
|
|
};
|
|
|
|
/**
|
|
* @short Identifies Expression instances based on their static type.
|
|
*
|
|
* BySequenceTypeIdentifier identifies Expression instances
|
|
* if their Expression::staticType() matches the requested one,
|
|
* regardless of whether the Expression is a particular one, such
|
|
* as AndExpression.
|
|
*
|
|
* For example, constructing a BySequenceTypeIdentifier while
|
|
* passing CommonSequenceTypes::EBV in its constructor will create
|
|
* a ExpressionIdentifier that returns @c true for a static type with
|
|
* item type <tt>xs:string</tt>, but returns @c false for a static type involving
|
|
* <tt>xs:date</tt>.
|
|
*
|
|
* @author Frans englich <frans.englich@nokia.com>
|
|
* @ingroup Patternist_expressions
|
|
*/
|
|
class BySequenceTypeIdentifier : public ExpressionIdentifier
|
|
{
|
|
public:
|
|
BySequenceTypeIdentifier(const SequenceType::Ptr &seqType);
|
|
|
|
/**
|
|
* @returns @c true, if the static type of @p expr is matches
|
|
* the SequenceType passed in the BySequenceTypeIdentifier()
|
|
* constructor, otherwise @c false.
|
|
*/
|
|
virtual bool matches(const Expression::Ptr &expr) const;
|
|
|
|
private:
|
|
const SequenceType::Ptr m_seqType;
|
|
};
|
|
|
|
/**
|
|
* @short Determines whether an Expression is a value or general comparison or both,
|
|
* with a certain operator.
|
|
*
|
|
* @author Frans englich <frans.englich@nokia.com>
|
|
* @ingroup Patternist_expressions
|
|
*/
|
|
class ComparisonIdentifier : public ExpressionIdentifier
|
|
{
|
|
public:
|
|
|
|
/**
|
|
* @param comparatorHosts the possible parent that may have
|
|
* the operator. This may be Expression::IDGeneralComparison or
|
|
* Expression::IDValueComparison. The two values may also be OR'd,
|
|
* meaning any of them will do.
|
|
*
|
|
* @param op the operator that the comparator host must have. For example,
|
|
* if @p op is AtomicComparator::OperatorGreatorOrEqual this ComparisonIdentifier
|
|
* will match operator >= in the case of IDGeneralComparison and 'ge' in the
|
|
* case of IDValueComparison.
|
|
*/
|
|
ComparisonIdentifier(const QVector<Expression::ID> comparatorHosts,
|
|
const AtomicComparator::Operator op);
|
|
|
|
/**
|
|
* @returns @c true, if @p expr is a ValueComparison with the operator
|
|
* passed in ComparisonIdentifier().
|
|
*/
|
|
virtual bool matches(const Expression::Ptr &expr) const;
|
|
|
|
private:
|
|
const QVector<Expression::ID> m_hosts;
|
|
const AtomicComparator::Operator m_op;
|
|
};
|
|
|
|
/**
|
|
* @short Matches numeric literals that are of type xs:integer and
|
|
* has a specific value.
|
|
*
|
|
* For example IntegerIdentifier(4) would match the former but
|
|
* not the latter operand in this expression: "4 + 5".
|
|
*
|
|
* @author Frans englich <frans.englich@nokia.com>
|
|
* @ingroup Patternist_expressions
|
|
*/
|
|
class IntegerIdentifier : public ExpressionIdentifier
|
|
{
|
|
public:
|
|
IntegerIdentifier(const xsInteger num);
|
|
virtual bool matches(const Expression::Ptr &expr) const;
|
|
|
|
private:
|
|
const xsInteger m_num;
|
|
};
|
|
|
|
/**
|
|
* @short Matches boolean literals.
|
|
*
|
|
* For example BooleanIdentifier(true) would match the former but
|
|
* not the latter operand in this expression: "true() + false()".
|
|
*
|
|
* @author Frans englich <frans.englich@nokia.com>
|
|
* @ingroup Patternist_expressions
|
|
*/
|
|
class BooleanIdentifier : public ExpressionIdentifier
|
|
{
|
|
public:
|
|
BooleanIdentifier(const bool value);
|
|
virtual bool matches(const Expression::Ptr &expr) const;
|
|
|
|
private:
|
|
const bool m_value;
|
|
};
|
|
|
|
/**
|
|
* @short Creates a particular Expression instance identified by an Expression::ID.
|
|
*
|
|
* For example, if ByIDCreator() is passed Expression::IDCountFN, create()
|
|
* will return CountFN instances.
|
|
*
|
|
* @author Frans englich <frans.englich@nokia.com>
|
|
* @ingroup Patternist_expressions
|
|
*/
|
|
class ByIDCreator : public ExpressionCreator
|
|
{
|
|
public:
|
|
/**
|
|
* Creates a ByIDCreator that creates expressions
|
|
* of the type that @p id identifies.
|
|
*/
|
|
ByIDCreator(const Expression::ID id);
|
|
virtual Expression::Ptr create(const Expression::List &operands,
|
|
const StaticContext::Ptr &context,
|
|
const SourceLocationReflection *const r) const;
|
|
|
|
/**
|
|
* Creates an expression by id @p id with the arguments @p operands.
|
|
*/
|
|
static Expression::Ptr create(const Expression::ID id,
|
|
const Expression::List &operands,
|
|
const StaticContext::Ptr &context,
|
|
const SourceLocationReflection *const r);
|
|
|
|
private:
|
|
const Expression::ID m_id;
|
|
};
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#endif
|