Qt 4.8
Public Functions | Static Public Functions | Properties | List of all members
QPatternist::ArithmeticExpression Class Reference

Implements arithmetics, such as multiplication and subtraction. More...

#include <qarithmeticexpression_p.h>

Inheritance diagram for QPatternist::ArithmeticExpression:
QPatternist::PairContainer QPatternist::Expression QSharedData QPatternist::CppCastingHelper< Expression > QPatternist::SourceLocationReflection QPatternist::UnaryExpression

Public Functions

virtual ExpressionVisitorResult::Ptr accept (const ExpressionVisitor::Ptr &visitor) const
 
 ArithmeticExpression (const Expression::Ptr &operand1, const AtomicMathematician::Operator op, const Expression::Ptr &operand2)
 
virtual Item evaluateSingleton (const DynamicContext::Ptr &context) const
 
virtual SequenceType::List expectedOperandTypes () const
 
AtomicMathematician::Operator operatorID () const
 
virtual SequenceType::Ptr staticType () const
 
virtual Expression::Ptr typeCheck (const StaticContext::Ptr &context, const SequenceType::Ptr &reqType)
 
- Public Functions inherited from QPatternist::PairContainer
virtual bool compressOperands (const StaticContext::Ptr &)
 
virtual Expression::List operands () const
 
virtual void setOperands (const Expression::List &operands)
 
- Public Functions inherited from QPatternist::Expression
virtual const SourceLocationReflectionactualReflection () const
 Returns this. More...
 
virtual void announceFocusType (const ItemType::Ptr &itemType)
 
virtual Expression::Ptr compress (const StaticContext::Ptr &context)
 
Properties deepProperties () const
 Computes the union of properties for this Expression and all its descending children. More...
 
virtual Properties dependencies () const
 
virtual QString description () const
 
virtual bool evaluateEBV (const DynamicContext::Ptr &context) const
 
virtual Item::Iterator::Ptr evaluateSequence (const DynamicContext::Ptr &context) const
 
virtual void evaluateToSequenceReceiver (const DynamicContext::Ptr &context) const
 
virtual ItemType::Ptr expectedContextItemType () const
 
 Expression ()
 
bool has (const Property prop) const
 
bool hasDependency (const Property prop) const
 
virtual ID id () const
 
bool is (const ID id) const
 
bool isEvaluated () const
 
virtual ItemType::Ptr newFocusType () const
 
virtual QList< QExplicitlySharedDataPointer< OptimizationPass > > optimizationPasses () const
 
virtual PatternPriority patternPriority () const
 
virtual Properties properties () const
 
const Expression::Ptrrewrite (const Expression::Ptr &to, const StaticContext::Ptr &context) const
 Rewrites this Expression to to, and return to. More...
 
virtual ~Expression ()
 
- Public Functions inherited from QSharedData
 QSharedData ()
 Constructs a QSharedData object with a reference count of 0. More...
 
 QSharedData (const QSharedData &)
 Constructs a QSharedData object with reference count 0. More...
 
- Public Functions inherited from QPatternist::CppCastingHelper< Expression >
const TCastTarget * as () const
 
TCastTarget * as ()
 
- Public Functions inherited from QPatternist::SourceLocationReflection
virtual QSourceLocation sourceLocation () const
 
 SourceLocationReflection ()
 
virtual ~SourceLocationReflection ()
 

Static Public Functions

static AtomicMathematician::Ptr fetchMathematician (Expression::Ptr &t1, Expression::Ptr &t2, const AtomicMathematician::Operator op, const bool issueError, const ReportContext::Ptr &context, const SourceLocationReflection *const reflection, const ReportContext::ErrorCode code=ReportContext::XPTY0004, const bool isCompat=false)
 
static Item flexiblyCalculate (const Item &op1, const AtomicMathematician::Operator op, const Item &op2, const AtomicMathematician::Ptr &mather, const DynamicContext::Ptr &context, const SourceLocationReflection *const reflection, const ReportContext::ErrorCode code=ReportContext::XPTY0004, const bool isCompat=false)
 
- Static Public Functions inherited from QPatternist::Expression
static void rewrite (Expression::Ptr &old, const Expression::Ptr &New, const StaticContext::Ptr &context)
 

Properties

bool m_isCompat
 
AtomicMathematician::Ptr m_mather
 
const AtomicMathematician::Operator m_op
 

Additional Inherited Members

- Public Types inherited from QPatternist::Expression
typedef QExplicitlySharedDataPointer< const ExpressionConstPtr
 A smart pointer wrapping const Expression instances. More...
 
enum  ID {
  IDBooleanValue = 1, IDCountFN, IDEmptyFN, IDExistsFN,
  IDExpressionSequence, IDGeneralComparison, IDIfThenClause, IDIgnorableExpression,
  IDIntegerValue, IDPositionFN, IDStringValue, IDValueComparison,
  IDRangeVariableReference, IDContextItem, IDUserFunctionCallsite, IDExpressionVariableReference,
  IDAttributeConstructor, IDUpperCaseFN, IDLowerCaseFN, IDFirstItemPredicate,
  IDEmptySequence, IDReturnOrderBy, IDLetClause, IDForClause,
  IDPath, IDNamespaceConstructor, IDArgumentReference, IDGenericPredicate,
  IDAxisStep, IDFloat, IDCombineNodes, IDUnresolvedVariableReference,
  IDCardinalityVerifier
}
 
typedef QList< Expression::PtrList
 
typedef QFlags< PropertyProperties
 
enum  Property {
  UseContextItem = 1, DisableElimination = 1 << 1, IsEvaluated = 1 << 2, DisableTypingDeduction = 1 << 3,
  EmptynessFollowsChild = 1 << 4, RewriteToEmptyOnEmpty = 1 << 5, RequiresFocus = 1 << 6, AffectsOrderOnly = 1 << 7,
  RequiresContextItem = (1 << 8) | RequiresFocus, CreatesFocusForLast = 1 << 9, LastOperandIsCollation = 1 << 10, DependsOnLocalVariable = (1 << 11) | DisableElimination,
  EvaluationCacheRedundant = (1 << 12), IsNodeConstructor = 1 << 13, RequiresCurrentItem = 1 << 14
}
 
typedef QExplicitlySharedDataPointer< ExpressionPtr
 A smart pointer wrapping mutable Expression instances. More...
 
typedef ::QAbstractXmlForwardIterator< Expression::PtrQAbstractXmlForwardIterator
 
typedef QVector< Expression::PtrVector
 
- Public Variables inherited from QSharedData
QAtomicInt ref
 
- Protected Functions inherited from QPatternist::PairContainer
 PairContainer (const Expression::Ptr &operand1, const Expression::Ptr &operand2)
 
- Protected Functions inherited from QPatternist::Expression
void typeCheckOperands (const StaticContext::Ptr &context)
 
- Protected Functions inherited from QPatternist::CppCastingHelper< Expression >
 CppCastingHelper ()
 
- Protected Variables inherited from QPatternist::PairContainer
Expression::Ptr m_operand1
 
Expression::Ptr m_operand2
 

Detailed Description

Implements arithmetics, such as multiplication and subtraction.

Optimizations: there's some operator/value combos that are no ops. For instance, 0 +

, which is the case of unary plus. We can't compile those away early due to that type checks needs to be done but one can check for them in compress().

See also
XML Path Language (XPath) 2.0, 3.4 Arithmetic Expressions
Author
Frans Englich frans.nosp@m..eng.nosp@m.lich@.nosp@m.noki.nosp@m.a.com

Definition at line 78 of file qarithmeticexpression_p.h.

Constructors and Destructors

◆ ArithmeticExpression()

ArithmeticExpression::ArithmeticExpression ( const Expression::Ptr operand1,
const AtomicMathematician::Operator  op,
const Expression::Ptr operand2 
)

Definition at line 58 of file qarithmeticexpression.cpp.

60  : PairContainer(op1, op2)
61  , m_op(op)
62  , m_isCompat(false)
63 {
64 }
PairContainer(const Expression::Ptr &operand1, const Expression::Ptr &operand2)
const AtomicMathematician::Operator m_op

Functions

◆ accept()

ExpressionVisitorResult::Ptr ArithmeticExpression::accept ( const ExpressionVisitor::Ptr visitor) const
virtual

Implements QPatternist::Expression.

Definition at line 358 of file qarithmeticexpression.cpp.

Referenced by fetchMathematician().

359 {
360  return visitor->visit(this);
361 }

◆ evaluateSingleton()

Item ArithmeticExpression::evaluateSingleton ( const DynamicContext::Ptr context) const
virtual

Reimplemented from QPatternist::Expression.

Reimplemented in QPatternist::UnaryExpression.

Definition at line 66 of file qarithmeticexpression.cpp.

67 {
68  const Item op1(m_operand1->evaluateSingleton(context));
69  if(!op1)
70  return Item();
71 
72  const Item op2(m_operand2->evaluateSingleton(context));
73  if(!op2)
74  return Item();
75 
76  return flexiblyCalculate(op1, m_op, op2, m_mather, context, this,
78 }
Represents an item in the XPath 2.0 Data Model.
Definition: qitem_p.h:182
static Item flexiblyCalculate(const Item &op1, const AtomicMathematician::Operator op, const Item &op2, const AtomicMathematician::Ptr &mather, const DynamicContext::Ptr &context, const SourceLocationReflection *const reflection, const ReportContext::ErrorCode code=ReportContext::XPTY0004, const bool isCompat=false)
virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const
const AtomicMathematician::Operator m_op

◆ expectedOperandTypes()

SequenceType::List ArithmeticExpression::expectedOperandTypes ( ) const
virtual

Returns a list of Sequence Types, describing the type of each of the expression's operands. Hence, this function has a relationship to the operands() function:

- The lengths of the lists returned by expectedOperandTypes()
and operands() should always be equal in length, since one
cannot describe the type of a non-existent operand(and all
operands must have type information).
- A significant difference between the two functions is that while
the type of objects in the list returned by operands() may vary
between compilations/static context, simply because the particular
Expression is part of different XPath expressions, the
types in the list returned by expectedOperandTypes is always the same
since the function/operator signature never changes.

This function should not be confused with staticType(), which returns the static type of the expression itself, not its operands. The function call is an expression where this is clear: the type of the return value is not the same as the arguments' types. The static type of the operands supplied to the expression can be determined via the staticType() function of the instances returned by operands().

If the expression has no operands, an empty list should be returned.

Implements QPatternist::Expression.

Definition at line 350 of file qarithmeticexpression.cpp.

351 {
352  SequenceType::List result;
355  return result;
356 }
void append(const T &t)
Inserts value at the end of the list.
Definition: qlist.h:507
static const SequenceType::Ptr ZeroOrOneAtomicType
The QList class is a template class that provides lists.
Definition: qdatastream.h:62

◆ fetchMathematician()

AtomicMathematician::Ptr ArithmeticExpression::fetchMathematician ( Expression::Ptr t1,
Expression::Ptr t2,
const AtomicMathematician::Operator  op,
const bool  issueError,
const ReportContext::Ptr context,
const SourceLocationReflection *const  reflection,
const ReportContext::ErrorCode  code = ReportContext::XPTY0004,
const bool  isCompat = false 
)
static

Definition at line 169 of file qarithmeticexpression.cpp.

Referenced by flexiblyCalculate(), typeCheck(), QPatternist::AddingAggregate::typeCheck(), and QPatternist::AvgFN::typeCheck().

177 {
178  ItemType::Ptr t1(op1->staticType()->itemType());
179  ItemType::Ptr t2(op2->staticType()->itemType());
180 
181  if(BuiltinTypes::xsUntypedAtomic->xdtTypeMatches(t1)
182  || (isCompat && (BuiltinTypes::xsString->xdtTypeMatches(t1)
183  || BuiltinTypes::xsDecimal->xdtTypeMatches(t1))))
184  {
186  /* The types might have changed, reload. */
187  t1 = op1->staticType()->itemType();
188  }
189 
190  if(BuiltinTypes::xsUntypedAtomic->xdtTypeMatches(t2)
191  || (isCompat && (BuiltinTypes::xsString->xdtTypeMatches(t1)
192  || BuiltinTypes::xsDecimal->xdtTypeMatches(t1))))
193  {
195  /* The types might have changed, reload. */
196  t2 = op2->staticType()->itemType();
197  }
198 
199  const AtomicMathematicianLocator::Ptr locator
200  (static_cast<const AtomicType *>(t1.data())->mathematicianLocator());
201 
202  if(!locator)
203  {
204  if(!issueError)
205  return AtomicMathematician::Ptr();
206 
207  context->error(QtXmlPatterns::tr(
208  "Operator %1 cannot be used on type %2.")
210  .arg(formatType(context->namePool(), t1)),
211  code, reflection);
212  return AtomicMathematician::Ptr();
213  }
214 
215  const AtomicMathematician::Ptr comp
216  (static_cast<const AtomicType *>(t2.data())->accept(locator, op, reflection));
217 
218  if(comp)
219  return comp;
220 
221  if(!issueError)
222  return AtomicMathematician::Ptr();
223 
224  context->error(QtXmlPatterns::tr("Operator %1 cannot be used on "
225  "atomic values of type %2 and %3.")
227  .arg(formatType(context->namePool(), t1))
228  .arg(formatType(context->namePool(), t2)),
229  code, reflection);
230  return AtomicMathematician::Ptr();
231 }
QString formatKeyword(const QString &keyword)
QString formatType(const NamePool::Ptr &np, const T &type)
Formats ItemType and SequenceType.
static const AtomicType::Ptr xsString
T * data() const
Returns a pointer to the shared data object.
Definition: qshareddata.h:145
static QString displayName(const AtomicMathematician::Operator op)
static const AtomicType::Ptr xsDouble
QExplicitlySharedDataPointer< AtomicMathematician > Ptr
static const AtomicType::Ptr xsUntypedAtomic
QExplicitlySharedDataPointer< Expression > Ptr
A smart pointer wrapping mutable Expression instances.
virtual SequenceType::Ptr staticType() const =0
Casts every item in a sequence obtained from evaluating an Expression, to a requested atomic type...
static const AtomicType::Ptr xsDecimal
virtual ItemType::Ptr itemType() const =0
virtual ExpressionVisitorResult::Ptr accept(const ExpressionVisitor::Ptr &visitor) const

◆ flexiblyCalculate()

Item ArithmeticExpression::flexiblyCalculate ( const Item op1,
const AtomicMathematician::Operator  op,
const Item op2,
const AtomicMathematician::Ptr mather,
const DynamicContext::Ptr context,
const SourceLocationReflection *const  reflection,
const ReportContext::ErrorCode  code = ReportContext::XPTY0004,
const bool  isCompat = false 
)
static

Definition at line 112 of file qarithmeticexpression.cpp.

Referenced by evaluateSingleton(), QPatternist::AvgFN::evaluateSingleton(), and QPatternist::SumFN::evaluateSingleton().

120 {
121  if(mather)
122  return mather->calculate(op1, op, op2, context);
123 
124  /* This is a very heavy code path. */
125  Expression::Ptr a1(new DelegatingReflectionExpression(op1, reflection));
126  Expression::Ptr a2(new DelegatingReflectionExpression(op2, reflection));
127 
128  const AtomicMathematician::Ptr ingela(fetchMathematician(a1, a2, op, true, context, reflection, code, isCompat));
129 
130  return ingela->calculate(a1->evaluateSingleton(context),
131  op,
132  a2->evaluateSingleton(context),
133  context);
134 }
static AtomicMathematician::Ptr fetchMathematician(Expression::Ptr &t1, Expression::Ptr &t2, const AtomicMathematician::Operator op, const bool issueError, const ReportContext::Ptr &context, const SourceLocationReflection *const reflection, const ReportContext::ErrorCode code=ReportContext::XPTY0004, const bool isCompat=false)
virtual Item calculate(const Item &operand1, const Operator op, const Item &operand2, const QExplicitlySharedDataPointer< DynamicContext > &context) const =0

◆ operatorID()

AtomicMathematician::Operator QPatternist::ArithmeticExpression::operatorID ( ) const
inline

Definition at line 122 of file qarithmeticexpression_p.h.

Referenced by QPatternist::UnaryExpression::evaluateSingleton().

123  {
124  return m_op;
125  }
const AtomicMathematician::Operator m_op

◆ staticType()

SequenceType::Ptr ArithmeticExpression::staticType ( ) const
virtual
Returns
the static type of this Expression. For example, an 'and' expression have as static type xs:boolean

Implements QPatternist::Expression.

Definition at line 233 of file qarithmeticexpression.cpp.

234 {
235  Cardinality card;
236 
237  /* These variables are important because they ensure staticType() only
238  * gets called once from this function. Before, this lead to strange
239  * semi-infinite recursion involving many arithmetic expressions. */
242 
243  if(st1->cardinality().allowsEmpty() ||
244  st2->cardinality().allowsEmpty())
245  {
246  card = Cardinality::zeroOrOne();
247  }
248  else
249  card = Cardinality::exactlyOne();
250 
252  return makeGenericSequenceType(BuiltinTypes::xsInteger, card);
253 
254  const ItemType::Ptr t1(st1->itemType());
255  const ItemType::Ptr t2(st2->itemType());
256  ItemType::Ptr returnType;
257 
258  /* Please, make this beautiful? */
259  if(BuiltinTypes::xsTime->xdtTypeMatches(t1) ||
260  BuiltinTypes::xsDate->xdtTypeMatches(t1) ||
261  BuiltinTypes::xsDateTime->xdtTypeMatches(t1))
262  {
263  if(BuiltinTypes::xsDuration->xdtTypeMatches(t2))
264  returnType = t1;
265  else
266  returnType = BuiltinTypes::xsDayTimeDuration;
267  }
268  else if(BuiltinTypes::xsYearMonthDuration->xdtTypeMatches(t1))
269  {
271  BuiltinTypes::xsYearMonthDuration->xdtTypeMatches(t2))
272  {
273  returnType = BuiltinTypes::xsDecimal;
274  }
275  else if(BuiltinTypes::numeric->xdtTypeMatches(t2))
277  else
278  returnType = t2;
279  }
280  else if(BuiltinTypes::xsYearMonthDuration->xdtTypeMatches(t2))
281  {
283  }
284  else if(BuiltinTypes::xsDayTimeDuration->xdtTypeMatches(t1))
285  {
287  BuiltinTypes::xsDayTimeDuration->xdtTypeMatches(t2))
288  {
289  returnType = BuiltinTypes::xsDecimal;
290  }
291  else if(BuiltinTypes::numeric->xdtTypeMatches(t2))
292  returnType = BuiltinTypes::xsDayTimeDuration;
293  else
294  returnType = t2;
295  }
296  else if(BuiltinTypes::xsDayTimeDuration->xdtTypeMatches(t2))
297  {
298  returnType = BuiltinTypes::xsDayTimeDuration;
299  }
300  else if(BuiltinTypes::xsDouble->xdtTypeMatches(t1) ||
301  BuiltinTypes::xsDouble->xdtTypeMatches(t2))
302  {
303  returnType = BuiltinTypes::xsDouble;
304  }
305  else if(BuiltinTypes::xsFloat->xdtTypeMatches(t1) ||
306  BuiltinTypes::xsFloat->xdtTypeMatches(t2))
307  {
308  if(m_isCompat)
309  returnType = BuiltinTypes::xsFloat;
310  else
311  returnType = BuiltinTypes::xsDouble;
312  }
313  else if(BuiltinTypes::xsInteger->xdtTypeMatches(t1) &&
314  BuiltinTypes::xsInteger->xdtTypeMatches(t2))
315  {
316  if(m_isCompat)
317  returnType = BuiltinTypes::xsDouble;
318  else
319  {
320  /* "A div B numeric numeric op:numeric-divide(A, B)
321  * numeric; but xs:decimal if both operands are xs:integer" */
323  returnType = BuiltinTypes::xsDecimal;
324  else
325  returnType = BuiltinTypes::xsInteger;
326  }
327  }
328  else if(m_isCompat && (BuiltinTypes::xsInteger->xdtTypeMatches(t1) &&
329  BuiltinTypes::xsInteger->xdtTypeMatches(t2)))
330  {
331  returnType = BuiltinTypes::xsDouble;
332  }
333  else
334  {
335  /* If typeCheck() has been called, our operands conform to expectedOperandTypes(), and
336  * the types are hence either xs:decimals, or xs:anyAtomicType(meaning the static type could
337  * not be inferred), or empty-sequence(). So we use the union of the two types. The combinations
338  * could also be wrong.*/
339  returnType = t1 | t2;
340 
341  /* However, if we're called before typeCheck(), we could potentially have nodes, so we need to make
342  * sure that the type is at least atomic. */
343  if(!BuiltinTypes::xsAnyAtomicType->xdtTypeMatches(returnType))
344  returnType = BuiltinTypes::xsAnyAtomicType;
345  }
346 
347  return makeGenericSequenceType(returnType, card);
348 }
static const AtomicType::Ptr xsDayTimeDuration
static const AtomicType::Ptr xsDuration
static const AtomicType::Ptr xsYearMonthDuration
static const AtomicType::Ptr xsDateTime
static const AtomicType::Ptr xsDouble
virtual SequenceType::Ptr staticType() const =0
static Cardinality zeroOrOne()
static const AtomicType::Ptr xsFloat
static const AtomicType::Ptr numeric
static const AtomicType::Ptr xsInteger
static Cardinality exactlyOne()
static const AtomicType::Ptr xsTime
static const AtomicType::Ptr xsDecimal
static const AtomicType::Ptr xsAnyAtomicType
Represents a cardinality, a possible , often represented by occurrence indicators.
static const AtomicType::Ptr xsDate
const AtomicMathematician::Operator m_op

◆ typeCheck()

Expression::Ptr ArithmeticExpression::typeCheck ( const StaticContext::Ptr context,
const SequenceType::Ptr reqType 
)
virtual

This implementation guarantees to never rewrite away this Expression, but at most rewrite it as a child of another expression(that presumably have a type checking role). It is therefore always safe to override this function and call this implementation and not worry about that this Expression becomes deleted.

Many Expressions override typeCheck() and performs optimizations, as opposed to doing it in the compress() stage. This is due to that the design of those Expressions often are tied to that certain simplifications are done at the typeCheck() stage of the compilation process or that it in some other way is related to what the typeCheck() do. Also, the earlier the AST can be simplified, the better the chances are for subsequent optimizations.

It is important that the super class's typeCheck() is called before doing any custom type checking, since the call can change the children(notably, the childrens' static types). For example, if the Expression, MyExpression in the example, does not match the required type, typeCheck returns the Expression wrapped in for example ItemVerifier, CardinalityVerifier, or both.

typeCheck() may be called many times. typeCheck() must either raise an error if this Expression is an invalid expression. Thus, it is guaranteed that an Expression is valid after typeCheck() is called.

Parameters
contextsupplies information, such as namespace bindings and available function signatures, that can be needed at compilation time. context is guaranteed by the caller to never null.
reqTypethe static type that this Expression must match when evaluated. reqType is guaranteed by the caller to never null.
Returns
an Expression that can be this Expression, or another expression, which somehow is necessary for making this Expression conforming to reqType

Reimplemented from QPatternist::Expression.

Definition at line 136 of file qarithmeticexpression.cpp.

138 {
139  m_isCompat = context->compatModeEnabled();
140 
141  const Expression::Ptr me(PairContainer::typeCheck(context, reqType));
144 
145  if(*CommonSequenceTypes::Empty == *t1 ||
147  {
148  return EmptySequence::create(this, context);
149  }
150 
151  if(*BuiltinTypes::xsAnyAtomicType == *t1 ||
153  *BuiltinTypes::numeric == *t1 ||
154  *BuiltinTypes::numeric == *t2)
155  {
156  /* The static type of (at least) one of the operands could not
157  * be narrowed further than xs:anyAtomicType, so we do the operator
158  * lookup at runtime. */
159  return me;
160  }
161 
162  m_mather = fetchMathematician(m_operand1, m_operand2, m_op, true, context, this,
164 
165  return me;
166 }
virtual bool compatModeEnabled() const =0
virtual Expression::Ptr typeCheck(const StaticContext::Ptr &context, const SequenceType::Ptr &reqType)
Definition: qexpression.cpp:70
static Expression::Ptr create(const Expression *const replacementFor, const StaticContext::Ptr &context)
Creates an EmptySequence that is a replacement for replacementFor.
static AtomicMathematician::Ptr fetchMathematician(Expression::Ptr &t1, Expression::Ptr &t2, const AtomicMathematician::Operator op, const bool issueError, const ReportContext::Ptr &context, const SourceLocationReflection *const reflection, const ReportContext::ErrorCode code=ReportContext::XPTY0004, const bool isCompat=false)
virtual SequenceType::Ptr staticType() const =0
static const EmptySequenceType::Ptr Empty
static const AtomicType::Ptr numeric
static const AtomicType::Ptr xsAnyAtomicType
virtual ItemType::Ptr itemType() const =0
const AtomicMathematician::Operator m_op

Properties

◆ m_isCompat

bool QPatternist::ArithmeticExpression::m_isCompat
private

Definition at line 119 of file qarithmeticexpression_p.h.

Referenced by evaluateSingleton(), staticType(), and typeCheck().

◆ m_mather

AtomicMathematician::Ptr QPatternist::ArithmeticExpression::m_mather
private

Definition at line 118 of file qarithmeticexpression_p.h.

Referenced by evaluateSingleton(), and typeCheck().

◆ m_op

const AtomicMathematician::Operator QPatternist::ArithmeticExpression::m_op
private

Definition at line 117 of file qarithmeticexpression_p.h.

Referenced by evaluateSingleton(), staticType(), and typeCheck().


The documentation for this class was generated from the following files: