--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/xmlpatterns/environment/qgenericstaticcontext.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,338 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/* Patternist */
+#include "qbasictypesfactory_p.h"
+#include "qcommonnamespaces_p.h"
+#include "qgenericdynamiccontext_p.h"
+#include "qfunctionfactorycollection_p.h"
+#include "qgenericnamespaceresolver_p.h"
+
+#include "qgenericstaticcontext_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+GenericStaticContext::GenericStaticContext(const NamePool::Ptr &np,
+ QAbstractMessageHandler *const handler,
+ const QUrl &aBaseURI,
+ const FunctionFactory::Ptr &factory,
+ const QXmlQuery::QueryLanguage lang) : m_boundarySpacePolicy(BSPStrip)
+ , m_constructionMode(CMPreserve)
+ , m_functionFactory(factory)
+ , m_defaultFunctionNamespace(CommonNamespaces::XFN)
+ , m_orderingEmptySequence(Greatest)
+ , m_orderingMode(Ordered)
+ , m_defaultCollation(QUrl::fromEncoded(CommonNamespaces::UNICODE_COLLATION))
+ , m_baseURI(aBaseURI)
+ , m_messageHandler(handler)
+ , m_preserveMode(Preserve)
+ , m_inheritMode(Inherit)
+ , m_namespaceResolver(lang == QXmlQuery::XQuery10
+ ? GenericNamespaceResolver::defaultXQueryBindings()
+ : GenericNamespaceResolver::defaultXSLTBindings())
+ , m_namePool(np)
+ , m_uriResolver(0)
+ , m_queryLanguage(lang)
+ , m_rangeSlot(-1)
+ , m_compatModeEnabled(false)
+{
+ /* We'll easily have at least this many AST nodes, that we need
+ * to track locations for. */
+ m_locations.reserve(30);
+
+ Q_ASSERT(np);
+ Q_ASSERT(!m_baseURI.isRelative());
+}
+
+NamespaceResolver::Ptr GenericStaticContext::namespaceBindings() const
+{
+ return m_namespaceResolver;
+}
+
+FunctionFactory::Ptr GenericStaticContext::functionSignatures() const
+{
+ return m_functionFactory;
+}
+
+DynamicContext::Ptr GenericStaticContext::dynamicContext() const
+{
+ GenericDynamicContext::Ptr context(new GenericDynamicContext(m_namePool, m_messageHandler, sourceLocations()));
+ // TODO we have many bugs here..
+ context->setResourceLoader(m_resourceLoader);
+ return context;
+}
+
+SchemaTypeFactory::Ptr GenericStaticContext::schemaDefinitions() const
+{
+ return BasicTypesFactory::self(m_namePool);
+}
+
+QUrl GenericStaticContext::baseURI() const
+{
+ Q_ASSERT_X(!m_baseURI.isRelative(), Q_FUNC_INFO,
+ "The static base-uri must be absolute. This error is most likely caused by misuing the API.");
+ return m_baseURI;
+}
+
+void GenericStaticContext::setBaseURI(const QUrl &uri)
+{
+ Q_ASSERT(!uri.isRelative());
+ m_baseURI = uri;
+}
+
+bool GenericStaticContext::compatModeEnabled() const
+{
+ return m_compatModeEnabled;
+}
+
+void GenericStaticContext::setCompatModeEnabled(const bool newVal)
+{
+ m_compatModeEnabled = newVal;
+}
+
+QUrl GenericStaticContext::defaultCollation() const
+{
+ return m_defaultCollation;
+}
+
+QAbstractMessageHandler * GenericStaticContext::messageHandler() const
+{
+ return m_messageHandler;
+}
+
+void GenericStaticContext::setDefaultCollation(const QUrl &uri)
+{
+ m_defaultCollation = uri;
+}
+
+void GenericStaticContext::setNamespaceBindings(const NamespaceResolver::Ptr &resolver)
+{
+ Q_ASSERT(resolver);
+ m_namespaceResolver = resolver;
+}
+
+StaticContext::BoundarySpacePolicy GenericStaticContext::boundarySpacePolicy() const
+{
+ return m_boundarySpacePolicy;
+}
+
+void GenericStaticContext::setBoundarySpacePolicy(const BoundarySpacePolicy policy)
+{
+ Q_ASSERT(policy == BSPPreserve || policy == BSPStrip);
+ m_boundarySpacePolicy = policy;
+}
+
+StaticContext::ConstructionMode GenericStaticContext::constructionMode() const
+{
+ return m_constructionMode;
+}
+
+void GenericStaticContext::setConstructionMode(const ConstructionMode mode)
+{
+ Q_ASSERT(mode == CMPreserve || mode == CMStrip);
+ m_constructionMode = mode;
+}
+
+StaticContext::OrderingMode GenericStaticContext::orderingMode() const
+{
+ return m_orderingMode;
+}
+
+void GenericStaticContext::setOrderingMode(const OrderingMode mode)
+{
+ Q_ASSERT(mode == Ordered || mode == Unordered);
+ m_orderingMode = mode;
+}
+
+StaticContext::OrderingEmptySequence GenericStaticContext::orderingEmptySequence() const
+{
+ return m_orderingEmptySequence;
+}
+
+void GenericStaticContext::setOrderingEmptySequence(const OrderingEmptySequence ordering)
+{
+ Q_ASSERT(ordering == Greatest || ordering == Least);
+ m_orderingEmptySequence = ordering;
+}
+
+QString GenericStaticContext::defaultFunctionNamespace() const
+{
+ return m_defaultFunctionNamespace;
+}
+
+void GenericStaticContext::setDefaultFunctionNamespace(const QString &ns)
+{
+ m_defaultFunctionNamespace = ns;
+}
+
+
+QString GenericStaticContext::defaultElementNamespace() const
+{
+ return m_defaultElementNamespace;
+}
+
+void GenericStaticContext::setDefaultElementNamespace(const QString &ns)
+{
+ m_defaultElementNamespace = ns;
+}
+
+StaticContext::InheritMode GenericStaticContext::inheritMode() const
+{
+ return m_inheritMode;
+}
+
+void GenericStaticContext::setInheritMode(const InheritMode mode)
+{
+ Q_ASSERT(mode == Inherit || mode == NoInherit);
+ m_inheritMode = mode;
+}
+
+StaticContext::PreserveMode GenericStaticContext::preserveMode() const
+{
+ return m_preserveMode;
+}
+
+void GenericStaticContext::setPreserveMode(const PreserveMode mode)
+{
+ Q_ASSERT(mode == Preserve || mode == NoPreserve);
+ m_preserveMode = mode;
+}
+
+ItemType::Ptr GenericStaticContext::contextItemType() const
+{
+ return m_contextItemType;
+}
+
+ItemType::Ptr GenericStaticContext::currentItemType() const
+{
+ return contextItemType();
+}
+
+void GenericStaticContext::setContextItemType(const ItemType::Ptr &type)
+{
+ m_contextItemType = type;
+}
+
+StaticContext::Ptr GenericStaticContext::copy() const
+{
+ GenericStaticContext *const retval = new GenericStaticContext(m_namePool, m_messageHandler, m_baseURI, m_functionFactory, m_queryLanguage);
+ const NamespaceResolver::Ptr newSolver(new GenericNamespaceResolver(m_namespaceResolver->bindings()));
+
+ retval->setNamespaceBindings(newSolver);
+ retval->setDefaultCollation(m_defaultCollation);
+ retval->setBoundarySpacePolicy(m_boundarySpacePolicy);
+ retval->setConstructionMode(m_constructionMode);
+ retval->setOrderingMode(m_orderingMode);
+ retval->setOrderingEmptySequence(m_orderingEmptySequence);
+ retval->setDefaultFunctionNamespace(m_defaultFunctionNamespace);
+ retval->setInheritMode(m_inheritMode);
+ retval->setPreserveMode(m_preserveMode);
+ retval->setExternalVariableLoader(m_externalVariableLoader);
+ retval->setResourceLoader(m_resourceLoader);
+ retval->setContextItemType(m_contextItemType);
+ retval->m_locations = m_locations;
+
+ return StaticContext::Ptr(retval);
+}
+
+ResourceLoader::Ptr GenericStaticContext::resourceLoader() const
+{
+ return m_resourceLoader;
+}
+
+void GenericStaticContext::setResourceLoader(const ResourceLoader::Ptr &loader)
+{
+ m_resourceLoader = loader;
+}
+
+ExternalVariableLoader::Ptr GenericStaticContext::externalVariableLoader() const
+{
+ return m_externalVariableLoader;
+}
+
+void GenericStaticContext::setExternalVariableLoader(const ExternalVariableLoader::Ptr &loader)
+{
+ m_externalVariableLoader = loader;
+}
+
+NamePool::Ptr GenericStaticContext::namePool() const
+{
+ return m_namePool;
+}
+
+void GenericStaticContext::addLocation(const SourceLocationReflection *const reflection,
+ const QSourceLocation &location)
+{
+ Q_ASSERT(!location.isNull());
+ Q_ASSERT_X(reflection, Q_FUNC_INFO,
+ "The reflection cannot be zero.");
+ m_locations.insert(reflection, location);
+}
+
+StaticContext::LocationHash GenericStaticContext::sourceLocations() const
+{
+ return m_locations;
+}
+
+QSourceLocation GenericStaticContext::locationFor(const SourceLocationReflection *const reflection) const
+{
+ return m_locations.value(reflection->actualReflection());
+}
+
+QAbstractUriResolver *GenericStaticContext::uriResolver() const
+{
+ return m_uriResolver;
+}
+
+VariableSlotID GenericStaticContext::currentRangeSlot() const
+{
+ return m_rangeSlot;
+}
+
+VariableSlotID GenericStaticContext::allocateRangeSlot()
+{
+ ++m_rangeSlot;
+ return m_rangeSlot;
+}
+
+QT_END_NAMESPACE