QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode > Class Template Reference

Provides comparison functionality for classes that compare Items, such as ValueComparison or MaxFN. More...

#include <qcomparisonplatform_p.h>

Protected Functions
const AtomicComparator::Ptr &	comparator () const
bool	compare (const Item &i1, const Item &i2, const AtomicComparator::Ptr &comp, const AtomicComparator::Operator op) const
	Compares i1 and i2 with operator op, using comparator comp. All input arguments must be valid, and not null. More...
	ComparisonPlatform ()
AtomicComparator::ComparisonResult	detailedFlexibleCompare (const Item &it1, const Item &it2, const DynamicContext::Ptr &context) const
	like flexibleCompare(), but returns the result as an AtomicComparator::Operator instead of bool. More...
AtomicComparator::Ptr	fetchComparator (const ItemType::Ptr &type1, const ItemType::Ptr &type2, const ReportContext::Ptr &context) const
bool	flexibleCompare (const Item &it1, const Item &it2, const DynamicContext::Ptr &context) const
	Compares it1 against it2, using comparator() and operatorID(). More...
void	prepareComparison (const AtomicComparator::Ptr &comparator)
void	useCaseInsensitiveComparator ()

Private Functions
AtomicComparator::Operator	operatorID () const

Properties
AtomicComparator::Ptr	m_comparator

Detailed Description

template<typename TSubClass, bool issueError, AtomicComparator::ComparisonType comparisonType = AtomicComparator::AsValueComparison, ReportContext::ErrorCode errorCode = ReportContext::XPTY0004>
class QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >

Provides comparison functionality for classes that compare Items, such as ValueComparison or MaxFN.

Classes which need comparison functionalities should inherit from this class.

The parameter of this template class is the class inheriting from ComparisonPlatform.

The class inheriting ComparisonPlatform must implement the following function:

AtomicComparator::Operator operatorID() const

Author

Vincent Ricard magic.nosp@m.@mag.nosp@m.icnin.nosp@m.ja.o.nosp@m.rg

Definition at line 89 of file qcomparisonplatform_p.h.

Constructors and Destructors

ComparisonPlatform()

template<typename TSubClass, bool issueError, AtomicComparator::ComparisonType comparisonType = AtomicComparator::AsValueComparison, ReportContext::ErrorCode errorCode = ReportContext::XPTY0004>

QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::ComparisonPlatform ( )

inlineprotected

Default constructor. Does nothing. It is implemented in order make template instantiation easier.

Definition at line 101 of file qcomparisonplatform_p.h.

        {
        }

Functions

comparator()

template<typename TSubClass, bool issueError, AtomicComparator::ComparisonType comparisonType = AtomicComparator::AsValueComparison, ReportContext::ErrorCode errorCode = ReportContext::XPTY0004>

const AtomicComparator::Ptr& QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::comparator ( ) const

inlineprotected

Returns

the AtomicComparator that has been allocated at compile time, with prepareComparison(). If no AtomicComparator has been allocated for some reason, this function returns null.

Definition at line 166 of file qcomparisonplatform_p.h.

        {
            return m_comparator;
        }

compare()

template<typename TSubClass , bool issueError, AtomicComparator::ComparisonType comparisonType, ReportContext::ErrorCode errorCode>

bool QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::compare ( const Item &  i1, const Item &  i2, const AtomicComparator::Ptr &  comp, const AtomicComparator::Operator  op  ) const

protected

Compares i1 and i2 with operator op, using comparator comp. All input arguments must be valid, and not null.

This is a fast, raw function which has the requirement that the caller knows what to compare and with what.

Definition at line 95 of file qcomparisonplatform.cpp.

Referenced by QPatternist::ComparisonPlatform< IndexOfIterator, false >::ComparisonPlatform().

{
    Q_ASSERT(oand1);
    Q_ASSERT(oand2);
    Q_ASSERT(comp);

    switch(op)
    {
        case AtomicComparator::OperatorEqual:
            return comp->equals(oand1, oand2);
        case AtomicComparator::OperatorNotEqual:
            return !comp->equals(oand1, oand2);
        case AtomicComparator::OperatorLessThanNaNLeast:
        case AtomicComparator::OperatorLessThanNaNGreatest:
        /* Fallthrough. */
        case AtomicComparator::OperatorLessThan:
            return comp->compare(oand1, op, oand2) == AtomicComparator::LessThan;
        case AtomicComparator::OperatorGreaterThan:
            return comp->compare(oand1, op, oand2) == AtomicComparator::GreaterThan;
        case AtomicComparator::OperatorLessOrEqual:
        {
            const AtomicComparator::ComparisonResult ret = comp->compare(oand1, op, oand2);
            return ret == AtomicComparator::LessThan || ret == AtomicComparator::Equal;
        }
        case(AtomicComparator::OperatorGreaterOrEqual):
        {
            const AtomicComparator::ComparisonResult ret = comp->compare(oand1, op, oand2);
            return ret == AtomicComparator::GreaterThan || ret == AtomicComparator::Equal;
        }
    }

    /* GCC unbarfer, this line should never be reached. */
    Q_ASSERT(false);
    return false;
}

detailedFlexibleCompare()

template<typename TSubClass , bool issueError, AtomicComparator::ComparisonType comparisonType, ReportContext::ErrorCode errorCode>

AtomicComparator::ComparisonResult QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::detailedFlexibleCompare ( const Item &  it1, const Item &  it2, const DynamicContext::Ptr &  context  ) const

protected

like flexibleCompare(), but returns the result as an AtomicComparator::Operator instead of bool.

This is useful when it is significant how a less than comparison fails; whether the two values are equal or greater than.

Definition at line 72 of file qcomparisonplatform.cpp.

Referenced by QPatternist::ComparisonPlatform< IndexOfIterator, false >::ComparisonPlatform(), and qLess< Item::List >::operator()().

{
    AtomicComparator::Ptr comp;

    if(m_comparator)
        comp = m_comparator;
    else
    {
        comp = fetchComparator(it1.type(),
                               it2.type(),
                               context);
    }

    Q_ASSERT_X(operatorID() == AtomicComparator::OperatorLessThanNaNLeast || operatorID() == AtomicComparator::OperatorLessThanNaNGreatest,
               Q_FUNC_INFO, "Only OperatorLessThan is currently supported for this function.");
    return comp->compare(it1, operatorID(), it2);
}

fetchComparator()

template<typename TSubClass , bool issueError, AtomicComparator::ComparisonType comparisonType, ReportContext::ErrorCode errorCode>

AtomicComparator::Ptr QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::fetchComparator ( const ItemType::Ptr &  type1, const ItemType::Ptr &  type2, const ReportContext::Ptr &  context  ) const

protected

Utility function for fetching the appropriate AtomicComparator for two atomic values of type type1 and type2, for the operator op.

This function is used throughout the implementation, ranging from the ValueComparison itself, to for example the aggregate functions.

Parameters

context	the ordinary ReportContext, used for issuing errors.
type1	the type of the first operand value in a comparison for which the returned AtomicComparator is intended for
type2	the type of the second operand value in a comparison for which the returned AtomicComparator is intended for. Whether type1 and type2 corresponds to what is the first second operand type does not have significance, the order can be arbitrary

Definition at line 137 of file qcomparisonplatform.cpp.

Referenced by QPatternist::ComparisonPlatform< IndexOfIterator, false >::ComparisonPlatform().

{
    Q_ASSERT(t1);
    Q_ASSERT(t2);

    if(*BuiltinTypes::xsAnyAtomicType == *t1    ||
       *BuiltinTypes::xsAnyAtomicType == *t2    ||
       *BuiltinTypes::item == *t1               ||
       *BuiltinTypes::item == *t2               ||
       *BuiltinTypes::numeric == *t1            ||
       *BuiltinTypes::numeric == *t2            ||
       *CommonSequenceTypes::Empty == *t1       ||
       *CommonSequenceTypes::Empty == *t2)
    {
        /* The static type of(at least) one of the operands could not
         * be narrowed further, so we do the operator
         * lookup at runtime.
         */
        return AtomicComparator::Ptr();
    }

    const AtomicComparatorLocator::Ptr locator
        (static_cast<const AtomicType *>(t1.data())->comparatorLocator());

    if(!locator)
    {
        if(issueError)
        {
            context->error(QtXmlPatterns::tr("No comparisons can be done involving the type %1.")
                                            .arg(formatType(context->namePool(), t1)),
                                       errorCode, static_cast<const TSubClass *>(this)->actualReflection());
        }
        return AtomicComparator::Ptr();
    }

    const AtomicComparator::Ptr comp(static_cast<const AtomicType *>(t2.data())->accept(locator, operatorID(),
                                                                                       static_cast<const TSubClass *>(this)->actualReflection()));

    if(comp)
        return comp;
    else if(issueError)
    {
        context->error(QtXmlPatterns::tr("Operator %1 is not available between atomic values of type %2 and %3.")
                                        .arg(formatKeyword(AtomicComparator::displayName(operatorID(),
                                                                                         comparisonType)),
                                             formatType(context->namePool(), t1),
                                             formatType(context->namePool(), t2)),
                                   errorCode, static_cast<const TSubClass *>(this)->actualReflection());
    }

    return AtomicComparator::Ptr();
}

flexibleCompare()

template<typename TSubClass , bool issueError, AtomicComparator::ComparisonType comparisonType, ReportContext::ErrorCode errorCode>

bool QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::flexibleCompare ( const Item &  it1, const Item &  it2, const DynamicContext::Ptr &  context  ) const

protected

Compares it1 against it2, using comparator() and operatorID().

If the comparator wasn't looked up at compile time, it will be attempted before comparing. If this fails, errors are reported via context.

Definition at line 51 of file qcomparisonplatform.cpp.

Referenced by QPatternist::ComparisonPlatform< IndexOfIterator, false >::ComparisonPlatform().

{
    if(m_comparator)
        /* The comparator was located at compile time. */
        return compare(it1, it2, m_comparator, operatorID());
    else
    {
        const AtomicComparator::Ptr cp(fetchComparator(it1.type(),
                                                       it2.type(),
                                                       context));

        return cp ? compare(it1, it2, cp, operatorID()) : false;
    }
}

operatorID()

template<typename TSubClass, bool issueError, AtomicComparator::ComparisonType comparisonType = AtomicComparator::AsValueComparison, ReportContext::ErrorCode errorCode = ReportContext::XPTY0004>

AtomicComparator::Operator QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::operatorID ( ) const

inlineprivate

Returns

the operator that is used.

Definition at line 186 of file qcomparisonplatform_p.h.

Referenced by QPatternist::ComparisonPlatform< IndexOfIterator, false >::operatorID().

        {
            Q_ASSERT(static_cast<const TSubClass *>(this)->operatorID());
            return static_cast<const TSubClass *>(this)->operatorID();
        }

prepareComparison()

template<typename TSubClass , bool issueError, AtomicComparator::ComparisonType comparisonType, ReportContext::ErrorCode errorCode>

void QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::prepareComparison ( const AtomicComparator::Ptr &  comparator )

protected

Makes ComparisonPlatform use the AtomicComparator comparator.

Definition at line 195 of file qcomparisonplatform.cpp.

{
    m_comparator = c;
}

useCaseInsensitiveComparator()

template<typename TSubClass, bool issueError, AtomicComparator::ComparisonType comparisonType = AtomicComparator::AsValueComparison, ReportContext::ErrorCode errorCode = ReportContext::XPTY0004>

void QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::useCaseInsensitiveComparator ( )

inlineprotected

Calling this function makes ComparisonPlatform use a comparator that compares strings case insensitively.

See also

ValueComparison::isCaseInsensitiveCompare()

Definition at line 177 of file qcomparisonplatform_p.h.

        {
            m_comparator = AtomicComparator::Ptr(new CaseInsensitiveStringComparator());
        }

Properties

m_comparator

template<typename TSubClass, bool issueError, AtomicComparator::ComparisonType comparisonType = AtomicComparator::AsValueComparison, ReportContext::ErrorCode errorCode = ReportContext::XPTY0004>

AtomicComparator::Ptr QPatternist::ComparisonPlatform< TSubClass, issueError, comparisonType, errorCode >::m_comparator

private

The comparator that is used for comparing atomic values. The AtomicComparator that is used, depends on the static type of the operands. m_comparator can be null if it wasn't possible to determine what comparator to use at compile time.

Definition at line 197 of file qcomparisonplatform_p.h.

Referenced by QPatternist::ComparisonPlatform< IndexOfIterator, false >::comparator(), and QPatternist::ComparisonPlatform< IndexOfIterator, false >::useCaseInsensitiveComparator().

---

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

• /src/xmlpatterns/expr/qcomparisonplatform_p.h
• /src/xmlpatterns/expr/qcomparisonplatform.cpp