1/****************************************************************************
2**
3** Copyright (C) 2016 The Qt Company Ltd.
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the QtXmlPatterns module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or (at your option) the GNU General
28** Public license version 3 or any later version approved by the KDE Free
29** Qt Foundation. The licenses are as published by the Free Software
30** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31** included in the packaging of this file. Please review the following
32** information to ensure the GNU General Public License requirements will
33** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34** https://www.gnu.org/licenses/gpl-3.0.html.
35**
36** $QT_END_LICENSE$
37**
38****************************************************************************/
39
40#include "qcommonsequencetypes_p.h"
41#include "qdelegatingnamespaceresolver_p.h"
42#include "qnamespaceconstructor_p.h"
43#include "qnodebuilder_p.h"
44#include "qoutputvalidator_p.h"
45#include "qqnamevalue_p.h"
46#include "qstaticnamespacecontext_p.h"
47
48#include "qelementconstructor_p.h"
49
50QT_BEGIN_NAMESPACE
51
52using namespace QPatternist;
53
54ElementConstructor::ElementConstructor(const Expression::Ptr &op1,
55 const Expression::Ptr &op2,
56 const bool isXSLT) : PairContainer(op1, op2)
57 , m_isXSLT(isXSLT)
58{
59}
60
61Item ElementConstructor::evaluateSingleton(const DynamicContext::Ptr &context) const
62{
63 const Item name(m_operand1->evaluateSingleton(context));
64
65 const NodeBuilder::Ptr nodeBuilder(context->nodeBuilder(baseURI: m_staticBaseURI));
66 OutputValidator validator(nodeBuilder.data(), context, this, m_isXSLT);
67
68 const DynamicContext::Ptr receiverContext(context->createReceiverContext(receiver: &validator));
69
70 nodeBuilder->startElement(name: name.as<QNameValue>()->qName());
71 m_operand2->evaluateToSequenceReceiver(context: receiverContext);
72 nodeBuilder->endElement();
73
74 const QAbstractXmlNodeModel::Ptr nm(nodeBuilder->builtDocument());
75 context->addNodeModel(nm);
76
77 return nm->root(n: QXmlNodeModelIndex());
78}
79
80void ElementConstructor::evaluateToSequenceReceiver(const DynamicContext::Ptr &context) const
81{
82 /* We create an OutputValidator here too. If we're serializing(a common
83 * case, unfortunately) the receiver is already validating in order to
84 * catch cases where a computed attribute constructor is followed by an
85 * element constructor, but in the cases where we're not serializing it's
86 * necessary that we validate in this step. */
87 const Item name(m_operand1->evaluateSingleton(context));
88 QAbstractXmlReceiver *const receiver = context->outputReceiver();
89
90 OutputValidator validator(receiver, context, this, m_isXSLT);
91 const DynamicContext::Ptr receiverContext(context->createReceiverContext(receiver: &validator));
92
93 receiver->startElement(name: name.as<QNameValue>()->qName());
94 m_operand2->evaluateToSequenceReceiver(context: receiverContext);
95 receiver->endElement();
96}
97
98Expression::Ptr ElementConstructor::typeCheck(const StaticContext::Ptr &context,
99 const SequenceType::Ptr &reqType)
100{
101 /* What does this code do? When type checking our children, our namespace
102 * bindings, which are also children of the form of NamespaceConstructor
103 * instances, must be statically in-scope for them, so find them and
104 * shuffle their bindings into the StaticContext. */
105
106 m_staticBaseURI = context->baseURI();
107
108 /* Namespace declarations changes the in-scope bindings, so let's
109 * first lookup our child NamespaceConstructors. */
110 const ID operandID = m_operand2->id();
111
112 NamespaceResolver::Bindings overrides;
113 if(operandID == IDExpressionSequence)
114 {
115 const Expression::List operands(m_operand2->operands());
116 const int len = operands.count();
117
118 for(int i = 0; i < len; ++i)
119 {
120 if(operands.at(i)->is(i: IDNamespaceConstructor))
121 {
122 const QXmlName &nb = operands.at(i)->as<NamespaceConstructor>()->namespaceBinding();
123 overrides.insert(akey: nb.prefix(), avalue: nb.namespaceURI());
124 }
125 }
126 }
127
128 const NamespaceResolver::Ptr newResolver(new DelegatingNamespaceResolver(context->namespaceBindings(), overrides));
129 const StaticContext::Ptr augmented(new StaticNamespaceContext(newResolver, context));
130
131 return PairContainer::typeCheck(context: augmented, reqType);
132}
133
134SequenceType::Ptr ElementConstructor::staticType() const
135{
136 return CommonSequenceTypes::ExactlyOneElement;
137}
138
139SequenceType::List ElementConstructor::expectedOperandTypes() const
140{
141 SequenceType::List result;
142 result.append(t: CommonSequenceTypes::ExactlyOneQName);
143 result.append(t: CommonSequenceTypes::ZeroOrMoreItems);
144 return result;
145}
146
147Expression::Properties ElementConstructor::properties() const
148{
149 return DisableElimination | IsNodeConstructor;
150}
151
152ExpressionVisitorResult::Ptr
153ElementConstructor::accept(const ExpressionVisitor::Ptr &visitor) const
154{
155 return visitor->visit(this);
156}
157
158QT_END_NAMESPACE
159

source code of qtxmlpatterns/src/xmlpatterns/expr/qelementconstructor.cpp