QPatternist::XSLT20CoreFunctions Class Reference

Handles the functions defines in XSL-T 2.0, except those also available in XPath 2.0. More...

#include <qxslt20corefunctions_p.h>

Inheritance diagram for QPatternist::XSLT20CoreFunctions:

Protected Functions
virtual Expression::Ptr	retrieveExpression (const QXmlName name, const Expression::List &args, const FunctionSignature::Ptr &sign) const
virtual FunctionSignature::Ptr	retrieveFunctionSignature (const NamePool::Ptr &np, const QXmlName name)
Protected Functions inherited from QPatternist::AbstractFunctionFactory
FunctionSignature::Ptr	addFunction (const QXmlName::LocalNameCode localName, const FunctionSignature::Arity minArgs, const FunctionSignature::Arity maxArgs, const SequenceType::Ptr &returnType, const Expression::Properties props)
FunctionSignature::Ptr	addFunction (const QXmlName::LocalNameCode &localName, const FunctionSignature::Arity minArgs, const FunctionSignature::Arity maxArgs, const SequenceType::Ptr &returnType, const Expression::ID id=Expression::IDIgnorableExpression, const Expression::Properties props=Expression::Properties(), const StandardNamespaces::ID ns=StandardNamespaces::fn)
Protected Functions inherited from QPatternist::FunctionFactory
	FunctionFactory ()
	This constructor cannot be removed, because it can't be synthesized, for some reason. More...

Additional Inherited Members
Public Types inherited from QPatternist::FunctionFactory
typedef QList< FunctionFactory::Ptr >	List
typedef QExplicitlySharedDataPointer< FunctionFactory >	Ptr
Public Functions inherited from QPatternist::AbstractFunctionFactory
virtual Expression::Ptr	createFunctionCall (const QXmlName name, const Expression::List &arguments, const StaticContext::Ptr &context, const SourceLocationReflection *const r)
virtual FunctionSignature::Hash	functionSignatures () const
Public Functions inherited from QPatternist::FunctionFactory
bool	hasSignature (const FunctionSignature::Ptr &signature) const
virtual bool	isAvailable (const NamePool::Ptr &np, const QXmlName name, const xsInteger arity)
virtual	~FunctionFactory ()
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 Variables inherited from QSharedData
QAtomicInt	ref
Static Protected Functions inherited from QPatternist::AbstractFunctionFactory
static QXmlName::LocalNameCode	argument (const NamePool::Ptr &np, const char *const name)
Protected Variables inherited from QPatternist::AbstractFunctionFactory
FunctionSignature::Hash	m_signatures

Detailed Description

Handles the functions defines in XSL-T 2.0, except those also available in XPath 2.0.

Note

XPath20CoreFunctions inherits from XPath10CoreFunctions only for implementation reasons, it does not supply the functions in the XPath10CoreFunctions factory.

See also

XQuery 1.0 and XPath 2.0 Functions and Operators

XML Path Language (XPath) Version 1.0, 4 Core Function Library

Author

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

Since

4.5

Definition at line 78 of file qxslt20corefunctions_p.h.

Functions

retrieveExpression()

Expression::Ptr XSLT20CoreFunctions::retrieveExpression ( const QXmlName  name, const Expression::List &  args, const FunctionSignature::Ptr &  sign  ) const

protectedvirtual

This function is responsible for creating the actual Expression, corresponding to localName and the function signature sign. It is called by createFunctionCall(), once it have been determined the function actually exists and have the correct arity.

This function will only be called for names in the fn namespace.

Implements QPatternist::AbstractFunctionFactory.

Definition at line 63 of file qxslt20corefunctions.cpp.

{
    Q_ASSERT(sign);

    Expression::Ptr fn;
#define testXSLTFN(ln, cname) else if(lname.localName() == StandardLocalNames::ln) fn = Expression::Ptr(new cname())

    if(false) /* Dummy for the macro handling. Will be optimized away anyway. */
        return Expression::Ptr();
    /* Alphabetic order. */
    testXSLTFN(current,                     CurrentFN);
    testXSLTFN(document,                    DocumentFN);
    testXSLTFN(element_available,           ElementAvailableFN);
    testXSLTFN(function_available,          FunctionAvailableFN);
    testXSLTFN(generate_id,                 GenerateIDFN);
    testXSLTFN(system_property,             SystemPropertyFN);
    testXSLTFN(type_available,              TypeAvailableFN);
    testXSLTFN(unparsed_entity_public_id,   UnparsedEntityPublicIDFN);
    testXSLTFN(unparsed_entity_uri,         UnparsedEntityURIFN);
    testXSLTFN(unparsed_text_available,     UnparsedTextAvailableFN);
    testXSLTFN(unparsed_text,               UnparsedTextFN);
#undef testXSLTFN

    Q_ASSERT(fn);
    fn->setOperands(args);
    fn->as<FunctionCall>()->setSignature(sign);

    return fn;
}

retrieveFunctionSignature()

FunctionSignature::Ptr XSLT20CoreFunctions::retrieveFunctionSignature ( const NamePool::Ptr &  np, const QXmlName  name  )

protectedvirtual

This is a convenience function for sub-classes. It retrieves the function signature for function with name name.

According to the specifications are function signatures identified by their name and arity, but currently is the arity not part of the signature.

If no function could be found for the given name, null is returned.

Implements QPatternist::FunctionFactory.

Definition at line 95 of file qxslt20corefunctions.cpp.

{
    if(StandardNamespaces::fn != name.namespaceURI())
        return FunctionSignature::Ptr();

    FunctionSignature::Ptr s(functionSignatures().value(name));

    if(!s)
    {
        /* Alphabetic order. */
        if(name.localName() == StandardLocalNames::element_available)
        {
            s = addFunction(StandardLocalNames::element_available, 1, 1, CommonSequenceTypes::ExactlyOneBoolean);
            s->appendArgument(argument(np, "element-name"), CommonSequenceTypes::ExactlyOneString);
        }
        else if(name.localName() == StandardLocalNames::function_available)
        {
            s = addFunction(StandardLocalNames::function_available, 1, 2, CommonSequenceTypes::ExactlyOneBoolean);
            s->appendArgument(argument(np, "function_name"), CommonSequenceTypes::ExactlyOneString);
            s->appendArgument(argument(np, "arity"), CommonSequenceTypes::ExactlyOneInteger);
        }
        else if(name.localName() == StandardLocalNames::type_available)
        {
            s = addFunction(StandardLocalNames::type_available, 1, 1, CommonSequenceTypes::ExactlyOneBoolean);
            s->appendArgument(argument(np, "type_name"), CommonSequenceTypes::ExactlyOneString);
        }
        else if(name.localName() == StandardLocalNames::system_property)
        {
            s = addFunction(StandardLocalNames::system_property, 1, 1, CommonSequenceTypes::ExactlyOneString);
            s->appendArgument(argument(np, "property_name"), CommonSequenceTypes::ExactlyOneString);
        }
        else if(name.localName() == StandardLocalNames::generate_id)
        {
            s = addFunction(StandardLocalNames::generate_id, 0, 1, CommonSequenceTypes::ExactlyOneString,
                            Expression::UseContextItem);
            s->appendArgument(argument(np, "node"), CommonSequenceTypes::ZeroOrOneNode);
        }
        else if(name.localName() == StandardLocalNames::unparsed_text)
        {
            s = addFunction(StandardLocalNames::unparsed_text, 1, 2, CommonSequenceTypes::ZeroOrOneString,
                            Expression::DisableElimination);
            s->appendArgument(argument(np, "href"), CommonSequenceTypes::ZeroOrOneString);
            s->appendArgument(argument(np, "encoding"), CommonSequenceTypes::ExactlyOneString);
        }
        else if(name.localName() == StandardLocalNames::unparsed_text_available)
        {
            s = addFunction(StandardLocalNames::unparsed_text_available, 1, 2, CommonSequenceTypes::ExactlyOneBoolean,
                            Expression::DisableElimination);
            s->appendArgument(argument(np, "href"), CommonSequenceTypes::ZeroOrOneString);
            s->appendArgument(argument(np, "encoding"), CommonSequenceTypes::ZeroOrOneString);
        }
        else if(name.localName() == StandardLocalNames::current)
        {
            s = addFunction(StandardLocalNames::current, 0, 0, CommonSequenceTypes::ExactlyOneItem,
                            Expression::DisableElimination | Expression::RequiresCurrentItem);
        }
        else if(name.localName() == StandardLocalNames::document)
        {
            s = addFunction(StandardLocalNames::document, 1, 2, CommonSequenceTypes::OneOrMoreDocumentNodes,
                            Expression::DisableElimination);
            s->appendArgument(argument(np, "uri-sequence"), CommonSequenceTypes::ZeroOrMoreStrings);
            s->appendArgument(argument(np, "base-uri-node"), CommonSequenceTypes::ExactlyOneNode);
        }
        else if(name.localName() == StandardLocalNames::unparsed_entity_uri)
        {
            s = addFunction(StandardLocalNames::unparsed_entity_uri, 1, 1, CommonSequenceTypes::ExactlyOneAnyURI,
                            Expression::RequiresFocus | Expression::DisableElimination);
            s->appendArgument(argument(np, "entity-name"), CommonSequenceTypes::ExactlyOneString);
        }
        else if(name.localName() == StandardLocalNames::unparsed_entity_public_id)
        {
            s = addFunction(StandardLocalNames::unparsed_entity_public_id, 1, 1, CommonSequenceTypes::ExactlyOneString,
                            Expression::RequiresFocus | Expression::DisableElimination);
            s->appendArgument(argument(np, "entity-name"), CommonSequenceTypes::ExactlyOneString);
        }
    }

    return s;
}

---

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

• /src/xmlpatterns/functions/qxslt20corefunctions_p.h
• /src/xmlpatterns/functions/qxslt20corefunctions.cpp