本文整理汇总了C++中expression::List::count方法的典型用法代码示例。如果您正苦于以下问题:C++ List::count方法的具体用法?C++ List::count怎么用?C++ List::count使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类expression::List
的用法示例。
在下文中一共展示了List::count方法的10个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: typeCheck
Expression::Ptr OrderBy::typeCheck(const StaticContext::Ptr &context,
const SequenceType::Ptr &reqType)
{
m_returnOrderBy->setStay(true);
/* It's important we do the typeCheck() before calling OrderSpec::prepare(), since
* atomizers must first be inserted. */
const Expression::Ptr me(SingleContainer::typeCheck(context, reqType));
const Expression::List ops(m_returnOrderBy->operands());
const int len = ops.count();
Q_ASSERT(ops.count() > 1);
Q_ASSERT(m_orderSpecs.count() == ops.count() - 1);
for(int i = 1; i < len; ++i)
m_orderSpecs[i - 1].prepare(ops.at(i), context);
return me;
/* It's not meaningful to sort a single item or less, so rewrite ourselves
* away if that is the case. This is an optimization. */
/* TODO: How do we remove ReturnOrderBy?
if(Cardinality::zeroOrOne().isMatch(m_operand->staticType()->cardinality()))
return m_operand->typeCheck(context, reqType);
else
return SingleContainer::typeCheck(context, reqType);
*/
}
示例2: typeCheck
Expression::Ptr ElementConstructor::typeCheck(const StaticContext::Ptr &context,
const SequenceType::Ptr &reqType)
{
/* What does this code do? When type checking our children, our namespace
* bindings, which are also children of the form of NamespaceConstructor
* instances, must be statically in-scope for them, so find them and
* shuffle their bindings into the StaticContext. */
m_staticBaseURI = context->baseURI();
/* Namespace declarations changes the in-scope bindings, so let's
* first lookup our child NamespaceConstructors. */
const ID operandID = m_operand2->id();
NamespaceResolver::Bindings overrides;
if(operandID == IDExpressionSequence)
{
const Expression::List operands(m_operand2->operands());
const int len = operands.count();
for(int i = 0; i < len; ++i)
{
if(operands.at(i)->is(IDNamespaceConstructor))
{
const QXmlName &nb = operands.at(i)->as<NamespaceConstructor>()->namespaceBinding();
overrides.insert(nb.prefix(), nb.namespaceURI());
}
}
}
const NamespaceResolver::Ptr newResolver(new DelegatingNamespaceResolver(context->namespaceBindings(), overrides));
const StaticContext::Ptr augmented(new StaticNamespaceContext(newResolver, context));
return PairContainer::typeCheck(augmented, reqType);
}
示例3: setOperands
void TripleContainer::setOperands(const Expression::List &ops)
{
Q_ASSERT(ops.count() == 3);
m_operand1 = ops.first();
m_operand2 = ops.at(1);
m_operand3 = ops.at(2);
}
示例4: typeCheck
Expression::Ptr ElementConstructor::typeCheck(const StaticContext::Ptr &context,
const SequenceType::Ptr &reqType)
{
m_staticBaseURI = context->baseURI();
/* Namespace declarations changes the in-scope bindings, so let's
* first lookup our child NamespaceConstructors. */
const ID operandID = m_operand2->id();
NamespaceResolver::Bindings overrides;
if(operandID == IDExpressionSequence)
{
const Expression::List operands(m_operand2->operands());
const int len = operands.count();
for(int i = 0; i < len; ++i)
{
if(operands.at(i)->is(IDNamespaceConstructor))
{
const QXmlName &nb = operands.at(i)->as<NamespaceConstructor>()->namespaceBinding();
overrides.insert(nb.prefix(), nb.namespaceURI());
}
}
}
const NamespaceResolver::Ptr newResolver(new DelegatingNamespaceResolver(context->namespaceBindings(), overrides));
const StaticContext::Ptr augmented(new StaticNamespaceContext(newResolver, context));
return PairContainer::typeCheck(augmented, reqType);
}
示例5: setOperands
void PairContainer::setOperands(const Expression::List &ops)
{
Q_ASSERT(ops.count() == 2);
m_operand1 = ops.first();
m_operand2 = ops.last();
Q_ASSERT(m_operand1);
Q_ASSERT(m_operand2);
}
示例6: compress
Expression::Ptr ExpressionSequence::compress(const StaticContext::Ptr &context)
{
const Expression::Ptr me(UnlimitedContainer::compress(context));
if(me != this)
return me;
Expression::List::const_iterator it(m_operands.constBegin());
const Expression::List::const_iterator end(m_operands.constEnd());
Expression::List result;
for(; it != end; ++it)
{
const ID Id = (*it)->id();
/* Remove empty sequences. This is rather important because we have some steps in the parser that
* intentionally, unconditionally and for temporary reasons create expressions like (expr, ()). Of course,
* empty sequences also occur as part of optimizations.
*
* User function call sites that are of type empty-sequence() must be avoided since
* they may contain calls to fn:error(), which we would rewrite away otherwise. */
if(Id != IDUserFunctionCallsite && (*it)->staticType()->cardinality().isEmpty())
{
/* Rewrite "(1, (), 2)" into "(1, 2)" by not
* adding (*it) to result. */
continue;
}
else if(Id == IDExpressionSequence)
{
/* Rewrite "(1, (2, 3), 4)" into "(1, 2, 3, 4)" */
Expression::List::const_iterator seqIt((*it)->operands().constBegin());
const Expression::List::const_iterator seqEnd((*it)->operands().constEnd());
for(; seqIt != seqEnd; ++seqIt)
result.append(*seqIt);
}
else
result.append(*it);
}
if(result.isEmpty())
return EmptySequence::create(this, context);
else if(result.count() == 1)
return result.first();
else
{
m_operands = result;
return me;
}
}
示例7: createFunctionCall
Expression::Ptr AbstractFunctionFactory::createFunctionCall(const QXmlName name,
const Expression::List &args,
const StaticContext::Ptr &context,
const SourceLocationReflection *const r)
{
const FunctionSignature::Ptr sign(retrieveFunctionSignature(context->namePool(), name));
if(!sign) /* The function doesn't exist(at least not in this factory). */
return Expression::Ptr();
/* May throw. */
verifyArity(sign, context, args.count(), r);
/* Ok, the function does exist and the arity is correct. */
return retrieveExpression(name, args, sign);
}
示例8: setOperands
void SingleContainer::setOperands(const Expression::List &ops)
{
Q_ASSERT(ops.count() == 1);
m_operand = ops.first();
}
示例9: UnlimitedContainer
ExpressionSequence::ExpressionSequence(const Expression::List &ops) : UnlimitedContainer(ops)
{
Q_ASSERT_X(1 < ops.count(), Q_FUNC_INFO,
"It makes no sense to have an ExpressionSequence containing less than two expressions.");
}
示例10: invokeOptimizers
Expression::Ptr Expression::invokeOptimizers(const Expression::Ptr &expr,
const StaticContext::Ptr &context)
{
Q_ASSERT(expr);
const OptimizationPass::List opts(expr->optimizationPasses());
if(opts.isEmpty()) /* Early exit. */
{
return expr;
}
const OptimizationPass::List::const_iterator passEnd(opts.constEnd());
const OptimizationPass::List::const_iterator end(opts.constEnd());
OptimizationPass::List::const_iterator passIt(opts.constBegin());
for(; passIt != passEnd; ++passIt) /* Invoke each optimization pass. */
{
const OptimizationPass::Ptr pass(*passIt); /* Alias, for readability. */
OptimizationPass::ExpressionMarker sourceMarker(pass->sourceExpression);
if(pass->startIdentifier && !pass->startIdentifier->matches(expr))
{
/* This pass specified a start identifier and it did
* not match -- let's try the next OptimizationPass. */
continue;
}
const ExpressionIdentifier::List::const_iterator idEnd(pass->operandIdentifiers.constEnd());
ExpressionIdentifier::List::const_iterator idIt(pass->operandIdentifiers.constBegin());
const Expression::List ops(expr->operands());
const Expression::List::const_iterator opEnd(ops.constEnd());
Expression::List::const_iterator opIt(ops.constBegin());
switch(pass->operandsMatchMethod)
{
case OptimizationPass::Sequential:
{
for(; opIt != opEnd; ++opIt)
{
const Expression::Ptr operand(*opIt); /* Alias, for readability. */
const ExpressionIdentifier::Ptr opIdentifier(*idIt); /* Alias, for readability. */
if(opIdentifier && !opIdentifier->matches(operand))
{
break;
}
++idIt;
}
if(opIt == opEnd)
break; /* All operands matched, so this pass matched. */
else
{
/* The loop above did not finish which means all operands did not match.
Therefore, this OptimizationPass did not match -- let's try the next one. */
continue;
}
}
case OptimizationPass::AnyOrder:
{
Q_ASSERT_X(ops.count() == 2, Q_FUNC_INFO,
"AnyOrder is currently only supported for Expressions with two operands.");
if(pass->operandIdentifiers.first()->matches(ops.first()) &&
pass->operandIdentifiers.last()->matches(ops.last()))
{
break;
}
else if(pass->operandIdentifiers.first()->matches(ops.last()) &&
pass->operandIdentifiers.last()->matches(ops.first()))
{
sourceMarker.first() = 1;
sourceMarker[1] = 0;
break; /* This pass matched. */
}
else
continue; /* This pass didn't match, let's loop through the next pass. */
}
}
/* Figure out the source Expression, if any. */
Expression::List operands;
Expression::Ptr sourceExpr;
if(!sourceMarker.isEmpty())
{
const OptimizationPass::ExpressionMarker::const_iterator mEnd(sourceMarker.constEnd());
OptimizationPass::ExpressionMarker::const_iterator mIt(sourceMarker.constBegin());
sourceExpr = expr;
for(; mIt != mEnd; ++mIt)
{
Q_ASSERT(*mIt >= 0);
sourceExpr = sourceExpr->operands().at(*mIt);
}
operands.append(sourceExpr);
}
if(operands.isEmpty())
//.........这里部分代码省略.........