src/third_party/WebKit/Source/core/xml/XPathPredicate.h

   1 /*
   2  * Copyright 2005 Frerich Raabe <raabe@kde.org>
   3  * Copyright (C) 2006 Apple Computer, Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #ifndef XPathPredicate_h
  28 #define XPathPredicate_h
  29
  30 #include "core/xml/XPathExpressionNode.h"
  31 #include "core/xml/XPathValue.h"
  32
  33 namespace WebCore {
  34
  35 namespace XPath {
  36
  37 class Number FINAL : public Expression {
  38 public:
  39     explicit Number(double);
  40     virtual void trace(Visitor*) OVERRIDE;
  41
  42 private:
  43     virtual Value evaluate() const OVERRIDE;
  44     virtual Value::Type resultType() const OVERRIDE { return Value::NumberValue; }
  45
  46     Value m_value;
  47 };
  48
  49 class StringExpression FINAL : public Expression {
  50 public:
  51     explicit StringExpression(const String&);
  52     virtual void trace(Visitor*) OVERRIDE;
  53
  54 private:
  55     virtual Value evaluate() const OVERRIDE;
  56     virtual Value::Type resultType() const OVERRIDE { return Value::StringValue; }
  57
  58     Value m_value;
  59 };
  60
  61 class Negative FINAL : public Expression {
  62 private:
  63     virtual Value evaluate() const OVERRIDE;
  64     virtual Value::Type resultType() const OVERRIDE { return Value::NumberValue; }
  65 };
  66
  67 class NumericOp FINAL : public Expression {
  68 public:
  69     enum Opcode {
  70         OP_Add, OP_Sub, OP_Mul, OP_Div, OP_Mod
  71     };
  72     NumericOp(Opcode, PassOwnPtrWillBeRawPtr<Expression> lhs, PassOwnPtrWillBeRawPtr<Expression> rhs);
  73
  74 private:
  75     virtual Value evaluate() const OVERRIDE;
  76     virtual Value::Type resultType() const OVERRIDE { return Value::NumberValue; }
  77
  78     Opcode m_opcode;
  79 };
  80
  81 class EqTestOp FINAL : public Expression {
  82 public:
  83     enum Opcode { OpcodeEqual, OpcodeNotEqual, OpcodeGreaterThan, OpcodeLessThan, OpcodeGreaterOrEqual, OpcodeLessOrEqual };
  84     EqTestOp(Opcode, PassOwnPtrWillBeRawPtr<Expression> lhs, PassOwnPtrWillBeRawPtr<Expression> rhs);
  85     virtual Value evaluate() const OVERRIDE;
  86
  87 private:
  88     virtual Value::Type resultType() const OVERRIDE { return Value::BooleanValue; }
  89     bool compare(const Value&, const Value&) const;
  90
  91     Opcode m_opcode;
  92 };
  93
  94 class LogicalOp FINAL : public Expression {
  95 public:
  96     enum Opcode { OP_And, OP_Or };
  97     LogicalOp(Opcode, PassOwnPtrWillBeRawPtr<Expression> lhs, PassOwnPtrWillBeRawPtr<Expression> rhs);
  98
  99 private:
 100     virtual Value::Type resultType() const OVERRIDE { return Value::BooleanValue; }
 101     bool shortCircuitOn() const;
 102     virtual Value evaluate() const OVERRIDE;
 103
 104     Opcode m_opcode;
 105 };
 106
 107 class Union FINAL : public Expression {
 108 private:
 109     virtual Value evaluate() const OVERRIDE;
 110     virtual Value::Type resultType() const OVERRIDE { return Value::NodeSetValue; }
 111 };
 112
 113 class Predicate FINAL : public NoBaseWillBeGarbageCollected<Predicate> {
 114     WTF_MAKE_NONCOPYABLE(Predicate); WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 115     DECLARE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(Predicate);
 116 public:
 117     explicit Predicate(PassOwnPtrWillBeRawPtr<Expression>);
 118     void trace(Visitor*);
 119
 120     bool evaluate() const;
 121     bool isContextPositionSensitive() const { return m_expr->isContextPositionSensitive() || m_expr->resultType() == Value::NumberValue; }
 122     bool isContextSizeSensitive() const { return m_expr->isContextSizeSensitive(); }
 123
 124 private:
 125     OwnPtrWillBeMember<Expression> m_expr;
 126 };
 127
 128 }
 129
 130 }
 131 #endif // XPathPredicate_h