1 /*
2 * Copyright 2006-2012 The FLWOR Foundation.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // ******************************************
18 // * *
19 // * THIS IS A GENERATED FILE. DO NOT EDIT! *
20 // * SEE .xml FILE WITH SAME NAME *
21 // * *
22 // ******************************************
23
24 #include "stdafx.h"
25 #include "zorbatypes/rchandle.h"
26 #include "zorbatypes/zstring.h"
27 #include "runtime/visitors/planiter_visitor.h"
28 #include "runtime/qnames/qnames.h"
29 #include "system/globalenv.h"
30
31
32
33 namespace zorba {
34
35 // <ResolveQNameIterator>
SERIALIZABLE_CLASS_VERSIONS(ResolveQNameIterator)36 SERIALIZABLE_CLASS_VERSIONS(ResolveQNameIterator)
37
38 void ResolveQNameIterator::serialize(::zorba::serialization::Archiver& ar)
39 {
40 serialize_baseclass(ar,
41 (BinaryBaseIterator<ResolveQNameIterator, PlanIteratorState>*)this);
42 }
43
44
accept(PlanIterVisitor & v) const45 void ResolveQNameIterator::accept(PlanIterVisitor& v) const
46 {
47 v.beginVisit(*this);
48
49 theChild0->accept(v);
50 theChild1->accept(v);
51
52 v.endVisit(*this);
53 }
54
~ResolveQNameIterator()55 ResolveQNameIterator::~ResolveQNameIterator() {}
56
57 // </ResolveQNameIterator>
58
59
60 // <QNameIterator>
SERIALIZABLE_CLASS_VERSIONS(QNameIterator)61 SERIALIZABLE_CLASS_VERSIONS(QNameIterator)
62
63 void QNameIterator::serialize(::zorba::serialization::Archiver& ar)
64 {
65 serialize_baseclass(ar,
66 (BinaryBaseIterator<QNameIterator, PlanIteratorState>*)this);
67 }
68
69
accept(PlanIterVisitor & v) const70 void QNameIterator::accept(PlanIterVisitor& v) const
71 {
72 v.beginVisit(*this);
73
74 theChild0->accept(v);
75 theChild1->accept(v);
76
77 v.endVisit(*this);
78 }
79
~QNameIterator()80 QNameIterator::~QNameIterator() {}
81
82 // </QNameIterator>
83
84
85 // <QNameEqualIterator>
SERIALIZABLE_CLASS_VERSIONS(QNameEqualIterator)86 SERIALIZABLE_CLASS_VERSIONS(QNameEqualIterator)
87
88 void QNameEqualIterator::serialize(::zorba::serialization::Archiver& ar)
89 {
90 serialize_baseclass(ar,
91 (BinaryBaseIterator<QNameEqualIterator, PlanIteratorState>*)this);
92 }
93
94
accept(PlanIterVisitor & v) const95 void QNameEqualIterator::accept(PlanIterVisitor& v) const
96 {
97 v.beginVisit(*this);
98
99 theChild0->accept(v);
100 theChild1->accept(v);
101
102 v.endVisit(*this);
103 }
104
~QNameEqualIterator()105 QNameEqualIterator::~QNameEqualIterator() {}
106
107 // </QNameEqualIterator>
108
109
110 // <PrefixFromQNameIterator>
SERIALIZABLE_CLASS_VERSIONS(PrefixFromQNameIterator)111 SERIALIZABLE_CLASS_VERSIONS(PrefixFromQNameIterator)
112
113 void PrefixFromQNameIterator::serialize(::zorba::serialization::Archiver& ar)
114 {
115 serialize_baseclass(ar,
116 (UnaryBaseIterator<PrefixFromQNameIterator, PlanIteratorState>*)this);
117 }
118
119
accept(PlanIterVisitor & v) const120 void PrefixFromQNameIterator::accept(PlanIterVisitor& v) const
121 {
122 v.beginVisit(*this);
123
124 theChild->accept(v);
125
126 v.endVisit(*this);
127 }
128
~PrefixFromQNameIterator()129 PrefixFromQNameIterator::~PrefixFromQNameIterator() {}
130
131 // </PrefixFromQNameIterator>
132
133
134 // <LocalNameFromQNameIterator>
SERIALIZABLE_CLASS_VERSIONS(LocalNameFromQNameIterator)135 SERIALIZABLE_CLASS_VERSIONS(LocalNameFromQNameIterator)
136
137 void LocalNameFromQNameIterator::serialize(::zorba::serialization::Archiver& ar)
138 {
139 serialize_baseclass(ar,
140 (UnaryBaseIterator<LocalNameFromQNameIterator, PlanIteratorState>*)this);
141 }
142
143
accept(PlanIterVisitor & v) const144 void LocalNameFromQNameIterator::accept(PlanIterVisitor& v) const
145 {
146 v.beginVisit(*this);
147
148 theChild->accept(v);
149
150 v.endVisit(*this);
151 }
152
~LocalNameFromQNameIterator()153 LocalNameFromQNameIterator::~LocalNameFromQNameIterator() {}
154
155 // </LocalNameFromQNameIterator>
156
157
158 // <NamespaceUriFromQNameIterator>
SERIALIZABLE_CLASS_VERSIONS(NamespaceUriFromQNameIterator)159 SERIALIZABLE_CLASS_VERSIONS(NamespaceUriFromQNameIterator)
160
161 void NamespaceUriFromQNameIterator::serialize(::zorba::serialization::Archiver& ar)
162 {
163 serialize_baseclass(ar,
164 (UnaryBaseIterator<NamespaceUriFromQNameIterator, PlanIteratorState>*)this);
165 }
166
167
accept(PlanIterVisitor & v) const168 void NamespaceUriFromQNameIterator::accept(PlanIterVisitor& v) const
169 {
170 v.beginVisit(*this);
171
172 theChild->accept(v);
173
174 v.endVisit(*this);
175 }
176
~NamespaceUriFromQNameIterator()177 NamespaceUriFromQNameIterator::~NamespaceUriFromQNameIterator() {}
178
179 // </NamespaceUriFromQNameIterator>
180
181
182 // <NamespaceUriForPrefixIterator>
SERIALIZABLE_CLASS_VERSIONS(NamespaceUriForPrefixIterator)183 SERIALIZABLE_CLASS_VERSIONS(NamespaceUriForPrefixIterator)
184
185 void NamespaceUriForPrefixIterator::serialize(::zorba::serialization::Archiver& ar)
186 {
187 serialize_baseclass(ar,
188 (NaryBaseIterator<NamespaceUriForPrefixIterator, PlanIteratorState>*)this);
189 }
190
191
accept(PlanIterVisitor & v) const192 void NamespaceUriForPrefixIterator::accept(PlanIterVisitor& v) const
193 {
194 v.beginVisit(*this);
195
196 std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
197 std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
198 for ( ; lIter != lEnd; ++lIter ){
199 (*lIter)->accept(v);
200 }
201
202 v.endVisit(*this);
203 }
204
~NamespaceUriForPrefixIterator()205 NamespaceUriForPrefixIterator::~NamespaceUriForPrefixIterator() {}
206
207 // </NamespaceUriForPrefixIterator>
208
209
210 // <InScopePrefixesIterator>
SERIALIZABLE_CLASS_VERSIONS(InScopePrefixesIterator)211 SERIALIZABLE_CLASS_VERSIONS(InScopePrefixesIterator)
212
213 void InScopePrefixesIterator::serialize(::zorba::serialization::Archiver& ar)
214 {
215 serialize_baseclass(ar,
216 (UnaryBaseIterator<InScopePrefixesIterator, InScopePrefixesIteratorState>*)this);
217 }
218
219
accept(PlanIterVisitor & v) const220 void InScopePrefixesIterator::accept(PlanIterVisitor& v) const
221 {
222 v.beginVisit(*this);
223
224 theChild->accept(v);
225
226 v.endVisit(*this);
227 }
228
~InScopePrefixesIterator()229 InScopePrefixesIterator::~InScopePrefixesIterator() {}
230
InScopePrefixesIteratorState()231 InScopePrefixesIteratorState::InScopePrefixesIteratorState() {}
232
~InScopePrefixesIteratorState()233 InScopePrefixesIteratorState::~InScopePrefixesIteratorState() {}
234
235 // </InScopePrefixesIterator>
236
237
238
239 }
240
241
242