QPatternist::CastingPlatform< TSubClass, issueError > Class Template Reference

Provides casting functionality for classes, such as CastAs or NumberFN, which needs to perform casting. More...

#include <qcastingplatform_p.h>

Protected Functions
Item	cast (const Item &sourceValue, const ReportContext::Ptr &context) const
	CastingPlatform (const ReportContext::ErrorCode code=ReportContext::FORG0001)
void	checkTargetType (const ReportContext::Ptr &context) const
bool	prepareCasting (const ReportContext::Ptr &context, const ItemType::Ptr &sourceType)

Private Functions
Item	castWithCaster (const Item &sourceValue, const AtomicCaster::Ptr &caster, const ReportContext::Ptr &context) const
Item	castWithCaster (const Item &sourceValue, const AtomicCaster::Ptr &caster, const DynamicContext::Ptr &context) const
void	issueCastError (const Item &validationError, const Item &sourceValue, const ReportContext::Ptr &context) const
ItemType::Ptr	targetType () const

Static Private Functions
static AtomicCaster::Ptr	locateCaster (const ItemType::Ptr &sourceType, const ReportContext::Ptr &context, bool &castImpossible, const SourceLocationReflection *const location, const ItemType::Ptr &targetType)

Properties
AtomicCaster::Ptr	m_caster
const ReportContext::ErrorCode	m_errorCode

Detailed Description

template<typename TSubClass, const bool issueError>
class QPatternist::CastingPlatform< TSubClass, issueError >

Provides casting functionality for classes, such as CastAs or NumberFN, which needs to perform casting.

Classes which need to perform casting can simply from this class and gain access to casting functinality wrapped in a convenient way. At the center of this class is the cast() function, which is used at runtime to perform the actual cast.

The actual circumstances where casting is used, such as in the 'castable as' expression or the fn:number() function, often have other things to handle as well, error handling and cardinality checks for example. This class handles only casting and leaves the other case-specific details to the sub-class such that this class only do one thing well.

This template class takes two parameters:

• TSubClass This should be the class inheriting from CastingPlatform.
• issueError if true, errors are issued via ReportContext, otherwise ValidationError instances are returned appropriately.

The class inheriting CastingPlatform must implement the following function:

ItemType::Ptr targetType() const

that returns the type that should be cast to. The type must be an AtomicType. Typically, it is appropriate to declare this function inline.

A sub-class calls prepareCasting() at compile time(such that CastingPlatform can attempt to lookup the proper AtomicCaster) and then it simply uses the cast() function at runtime. The function targetType() must be implemented such that CastingPlatform knows what type it shall cast to.

See also

ValueFactory

Author

Frans Englich frans.nosp@m..eng.nosp@m.lich@.nosp@m.noki.nosp@m.a.com

Definition at line 110 of file qcastingplatform_p.h.

Constructors and Destructors

CastingPlatform()

template<typename TSubClass, const bool issueError>

QPatternist::CastingPlatform< TSubClass, issueError >::CastingPlatform ( const ReportContext::ErrorCode  code = ReportContext::FORG0001 )

inlineprotected

Note

issueCastError() depends on the default value.

Definition at line 116 of file qcastingplatform_p.h.

                                                                                          : m_errorCode(code)
        {
        }

Functions

cast()

template<typename TSubClass , const bool issueError>

Item QPatternist::CastingPlatform< TSubClass, issueError >::cast ( const Item &  sourceValue, const ReportContext::Ptr &  context  ) const

protected

Attempts to cast sourceValue to targetType(), and returns the created value. Remember that prepareCasting() should have been called at compile time, otherwise this function will be slow.

Error reporting is done in two ways. If a cast fails because of an error in lexical representation a ValidationError is returned. If the cause of failure is that the casting combination is invalid(such as when attempting to cast xs:date to xs:integer), a ValidationError is returned if false was passed in the template instantiation, an error is issued via context.

Parameters

sourceValue	the value to cast. Must be non null.
context	the usual ReportContext, used for error reporting.

Returns

the new value which was the result of the cast. If the cast failed, an ValidationError is returned.

Definition at line 74 of file qcastingplatform.cpp.

Referenced by QPatternist::CastingPlatform< UntypedAtomicConverter, true >::CastingPlatform().

{
    Q_ASSERT(sourceValue);
    Q_ASSERT(context);
    Q_ASSERT(targetType());

    if(m_caster)
        return castWithCaster(sourceValue, m_caster, context);
    else
    {
        bool castImpossible = false;
        const AtomicCaster::Ptr caster(locateCaster(sourceValue.type(), context, castImpossible, static_cast<const TSubClass *>(this), targetType()));

        if(!issueError && castImpossible)
        {
            /* If we're supposed to issue an error(issueError) then this
             * line will never be reached, because locateCaster() will in
             * that case throw. */
            return ValidationError::createError();
        }
        else
            return castWithCaster(sourceValue, caster, context);
    }
}

castWithCaster() [1/2]

template<typename TSubClass , const bool issueError>

Item QPatternist::CastingPlatform< TSubClass, issueError >::castWithCaster ( const Item &  sourceValue, const AtomicCaster::Ptr &  caster, const ReportContext::Ptr &  context  ) const

inlineprivate

Definition at line 49 of file qcastingplatform.cpp.

Referenced by QPatternist::CastingPlatform< UntypedAtomicConverter, true >::CastingPlatform().

{
    Q_ASSERT(sourceValue);
    Q_ASSERT(caster);
    Q_ASSERT(context);

    const Item retval(caster->castFrom(sourceValue, context));

    if(issueError)
    {
        if(retval.template as<AtomicValue>()->hasError())
        {
            issueCastError(retval, sourceValue, context);
            return Item();
        }
        else
            return retval;
    }
    else
        return retval;
}

castWithCaster() [2/2]

template<typename TSubClass, const bool issueError>

Item QPatternist::CastingPlatform< TSubClass, issueError >::castWithCaster ( const Item &  sourceValue, const AtomicCaster::Ptr &  caster, const DynamicContext::Ptr &  context  ) const

inlineprivate

checkTargetType()

template<typename TSubClass , const bool issueError>

void QPatternist::CastingPlatform< TSubClass, issueError >::checkTargetType ( const ReportContext::Ptr &  context ) const

protected

Checks that the targetType() is a valid target type for castable as and cast as. For example, that it is not abstract. If the type is invalid, an error is raised via the context. Note that it is assumed the type is atomic.

Definition at line 166 of file qcastingplatform.cpp.

Referenced by QPatternist::CastingPlatform< UntypedAtomicConverter, true >::CastingPlatform().

{
    Q_ASSERT(context);

    const ItemType::Ptr tType(targetType());
    Q_ASSERT(tType);
    Q_ASSERT(tType->isAtomicType());
    const AtomicType::Ptr asAtomic(tType);

    /* This catches casting to xs:NOTATION and xs:anyAtomicType. */
    if(asAtomic->isAbstract())
    {
        context->error(QtXmlPatterns::tr("Casting to %1 is not possible because it "
                                     "is an abstract type, and can therefore never be instantiated.")
                                .arg(formatType(context->namePool(), tType)),
                          ReportContext::XPST0080,
                          static_cast<const TSubClass*>(this));
    }
}

issueCastError()

template<typename TSubClass , const bool issueError>

void QPatternist::CastingPlatform< TSubClass, issueError >::issueCastError ( const Item &  validationError, const Item &  sourceValue, const ReportContext::Ptr &  context  ) const

private

Definition at line 187 of file qcastingplatform.cpp.

Referenced by QPatternist::CastingPlatform< UntypedAtomicConverter, true >::targetType().

{
    Q_ASSERT(validationError);
    Q_ASSERT(context);
    Q_ASSERT(validationError.isAtomicValue());
    Q_ASSERT(validationError.template as<AtomicValue>()->hasError());

    const ValidationError::Ptr err(validationError.template as<ValidationError>());
    QString msg(err->message());

    if(msg.isNull())
    {
        msg = QtXmlPatterns::tr("It's not possible to cast the value %1 of type %2 to %3")
                 .arg(formatData(sourceValue.stringValue()))
                 .arg(formatType(context->namePool(), sourceValue.type()))
                 .arg(formatType(context->namePool(), targetType()));
    }
    else
    {
        Q_ASSERT(!msg.isEmpty());
        msg = QtXmlPatterns::tr("Failure when casting from %1 to %2: %3")
                 .arg(formatType(context->namePool(), sourceValue.type()))
                 .arg(formatType(context->namePool(), targetType()))
                 .arg(msg);
    }

    /* If m_errorCode is FORG0001, we assume our sub-classer doesn't have a
     * special wish about error code, so then we use the error object's code.
     */
    context->error(msg, m_errorCode == ReportContext::FORG0001 ? err->errorCode() : m_errorCode,
                   static_cast<const TSubClass*>(this));
}

locateCaster()

template<typename TSubClass , const bool issueError>

AtomicCaster::Ptr QPatternist::CastingPlatform< TSubClass, issueError >::locateCaster ( const ItemType::Ptr &  sourceType, const ReportContext::Ptr &  context, bool &  castImpossible, const SourceLocationReflection *const  location, const ItemType::Ptr &  targetType  )

staticprivate

Locates the caster for casting values of type sourceType to targetType(), if possible.

castImpossible is not initialized. Initialize it to false.

Definition at line 121 of file qcastingplatform.cpp.

Referenced by QPatternist::CastingPlatform< UntypedAtomicConverter, true >::CastingPlatform().

{
    Q_ASSERT(sourceType);
    Q_ASSERT(targetType);

    const AtomicCasterLocator::Ptr locator(static_cast<AtomicType *>(
            targetType.data())->casterLocator());
    if(!locator)
    {
        if(issueError)
        {
            context->error(QtXmlPatterns::tr("No casting is possible with %1 as the target type.")
                                        .arg(formatType(context->namePool(), targetType)),
                                       ReportContext::XPTY0004, location);
        }
        else
            castImpossible = true;

        return AtomicCaster::Ptr();
    }

    const AtomicCaster::Ptr caster(static_cast<const AtomicType *>(sourceType.data())->accept(locator, location));
    if(!caster)
    {
        if(issueError)
        {
            context->error(QtXmlPatterns::tr("It is not possible to cast from %1 to %2.")
                                            .arg(formatType(context->namePool(), sourceType))
                                            .arg(formatType(context->namePool(), targetType)),
                                       ReportContext::XPTY0004, location);
        }
        else
            castImpossible = true;

        return AtomicCaster::Ptr();
    }

    return caster;
}

prepareCasting()

template<typename TSubClass , const bool issueError>

bool QPatternist::CastingPlatform< TSubClass, issueError >::prepareCasting ( const ReportContext::Ptr &  context, const ItemType::Ptr &  sourceType  )

protected

This function should be called at compiled time, it attempts to determine what AtomicCaster that should be used when casting from sourceType to targetType(). If that is not possible, because the sourceType is xs:anyAtomicType for instance, the AtomicCaster lookup will done at runtime on a case-per-case basis.

Returns

true if the requested casting combination is valid or might be valid. If it is guranteed to be invalid, false is returned.

Definition at line 101 of file qcastingplatform.cpp.

Referenced by QPatternist::CastingPlatform< UntypedAtomicConverter, true >::CastingPlatform().

{
    Q_ASSERT(sourceType);
    Q_ASSERT(context);

    if(*sourceType == *BuiltinTypes::xsAnyAtomicType ||
       *sourceType == *BuiltinTypes::item ||
       *sourceType == *CommonSequenceTypes::Empty ||
       *sourceType == *BuiltinTypes::numeric)
        return true; /* The type could not be narrowed better than xs:anyAtomicType
                        or numeric at compile time. We'll do lookup at runtime instead. */

    bool castImpossible = false;
    m_caster = locateCaster(sourceType, context, castImpossible, static_cast<const TSubClass *>(this), targetType());

    return !castImpossible;
}

targetType()

template<typename TSubClass, const bool issueError>

ItemType::Ptr QPatternist::CastingPlatform< TSubClass, issueError >::targetType ( ) const

inlineprivate

Definition at line 183 of file qcastingplatform_p.h.

Referenced by QPatternist::CastingPlatform< UntypedAtomicConverter, true >::CastingPlatform(), and QPatternist::CastingPlatform< UntypedAtomicConverter, true >::targetType().

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

Properties

m_caster

template<typename TSubClass, const bool issueError>

AtomicCaster::Ptr QPatternist::CastingPlatform< TSubClass, issueError >::m_caster

private

Definition at line 194 of file qcastingplatform_p.h.

m_errorCode

template<typename TSubClass, const bool issueError>

const ReportContext::ErrorCode QPatternist::CastingPlatform< TSubClass, issueError >::m_errorCode

private

Definition at line 195 of file qcastingplatform_p.h.

---

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

• /src/xmlpatterns/expr/qcastingplatform_p.h
• /src/xmlpatterns/expr/qcastingplatform.cpp