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/numerics/numerics.h"
29 #include "system/globalenv.h"
30
31
32
33 namespace zorba {
34
35 // <AbsIterator>
SERIALIZABLE_CLASS_VERSIONS(AbsIterator)36 SERIALIZABLE_CLASS_VERSIONS(AbsIterator)
37
38 void AbsIterator::serialize(::zorba::serialization::Archiver& ar)
39 {
40 serialize_baseclass(ar,
41 (NaryBaseIterator<AbsIterator, PlanIteratorState>*)this);
42 }
43
44
accept(PlanIterVisitor & v) const45 void AbsIterator::accept(PlanIterVisitor& v) const
46 {
47 v.beginVisit(*this);
48
49 std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
50 std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
51 for ( ; lIter != lEnd; ++lIter ){
52 (*lIter)->accept(v);
53 }
54
55 v.endVisit(*this);
56 }
57
~AbsIterator()58 AbsIterator::~AbsIterator() {}
59
60 // </AbsIterator>
61
62
63 // <CeilingIterator>
SERIALIZABLE_CLASS_VERSIONS(CeilingIterator)64 SERIALIZABLE_CLASS_VERSIONS(CeilingIterator)
65
66 void CeilingIterator::serialize(::zorba::serialization::Archiver& ar)
67 {
68 serialize_baseclass(ar,
69 (NaryBaseIterator<CeilingIterator, PlanIteratorState>*)this);
70 }
71
72
accept(PlanIterVisitor & v) const73 void CeilingIterator::accept(PlanIterVisitor& v) const
74 {
75 v.beginVisit(*this);
76
77 std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
78 std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
79 for ( ; lIter != lEnd; ++lIter ){
80 (*lIter)->accept(v);
81 }
82
83 v.endVisit(*this);
84 }
85
~CeilingIterator()86 CeilingIterator::~CeilingIterator() {}
87
88 // </CeilingIterator>
89
90
91 // <FloorIterator>
SERIALIZABLE_CLASS_VERSIONS(FloorIterator)92 SERIALIZABLE_CLASS_VERSIONS(FloorIterator)
93
94 void FloorIterator::serialize(::zorba::serialization::Archiver& ar)
95 {
96 serialize_baseclass(ar,
97 (NaryBaseIterator<FloorIterator, PlanIteratorState>*)this);
98 }
99
100
accept(PlanIterVisitor & v) const101 void FloorIterator::accept(PlanIterVisitor& v) const
102 {
103 v.beginVisit(*this);
104
105 std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
106 std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
107 for ( ; lIter != lEnd; ++lIter ){
108 (*lIter)->accept(v);
109 }
110
111 v.endVisit(*this);
112 }
113
~FloorIterator()114 FloorIterator::~FloorIterator() {}
115
116 // </FloorIterator>
117
118
119 // <RoundIterator>
SERIALIZABLE_CLASS_VERSIONS(RoundIterator)120 SERIALIZABLE_CLASS_VERSIONS(RoundIterator)
121
122 void RoundIterator::serialize(::zorba::serialization::Archiver& ar)
123 {
124 serialize_baseclass(ar,
125 (NaryBaseIterator<RoundIterator, PlanIteratorState>*)this);
126 }
127
128
accept(PlanIterVisitor & v) const129 void RoundIterator::accept(PlanIterVisitor& v) const
130 {
131 v.beginVisit(*this);
132
133 std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
134 std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
135 for ( ; lIter != lEnd; ++lIter ){
136 (*lIter)->accept(v);
137 }
138
139 v.endVisit(*this);
140 }
141
~RoundIterator()142 RoundIterator::~RoundIterator() {}
143
144 // </RoundIterator>
145
146
147 // <RoundHalfToEvenIterator>
SERIALIZABLE_CLASS_VERSIONS(RoundHalfToEvenIterator)148 SERIALIZABLE_CLASS_VERSIONS(RoundHalfToEvenIterator)
149
150 void RoundHalfToEvenIterator::serialize(::zorba::serialization::Archiver& ar)
151 {
152 serialize_baseclass(ar,
153 (NaryBaseIterator<RoundHalfToEvenIterator, PlanIteratorState>*)this);
154 }
155
156
accept(PlanIterVisitor & v) const157 void RoundHalfToEvenIterator::accept(PlanIterVisitor& v) const
158 {
159 v.beginVisit(*this);
160
161 std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
162 std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
163 for ( ; lIter != lEnd; ++lIter ){
164 (*lIter)->accept(v);
165 }
166
167 v.endVisit(*this);
168 }
169
~RoundHalfToEvenIterator()170 RoundHalfToEvenIterator::~RoundHalfToEvenIterator() {}
171
172 // </RoundHalfToEvenIterator>
173
174
175 // <FormatNumberIterator>
SERIALIZABLE_CLASS_VERSIONS(FormatNumberIterator)176 SERIALIZABLE_CLASS_VERSIONS(FormatNumberIterator)
177
178 void FormatNumberIterator::serialize(::zorba::serialization::Archiver& ar)
179 {
180 serialize_baseclass(ar,
181 (NaryBaseIterator<FormatNumberIterator, PlanIteratorState>*)this);
182 }
183
184
accept(PlanIterVisitor & v) const185 void FormatNumberIterator::accept(PlanIterVisitor& v) const
186 {
187 v.beginVisit(*this);
188
189 std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
190 std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
191 for ( ; lIter != lEnd; ++lIter ){
192 (*lIter)->accept(v);
193 }
194
195 v.endVisit(*this);
196 }
197
~FormatNumberIterator()198 FormatNumberIterator::~FormatNumberIterator() {}
199
200 // </FormatNumberIterator>
201
202
203 // <FormatIntegerIterator>
SERIALIZABLE_CLASS_VERSIONS(FormatIntegerIterator)204 SERIALIZABLE_CLASS_VERSIONS(FormatIntegerIterator)
205
206 void FormatIntegerIterator::serialize(::zorba::serialization::Archiver& ar)
207 {
208 serialize_baseclass(ar,
209 (NaryBaseIterator<FormatIntegerIterator, PlanIteratorState>*)this);
210 }
211
212
accept(PlanIterVisitor & v) const213 void FormatIntegerIterator::accept(PlanIterVisitor& v) const
214 {
215 v.beginVisit(*this);
216
217 std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
218 std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
219 for ( ; lIter != lEnd; ++lIter ){
220 (*lIter)->accept(v);
221 }
222
223 v.endVisit(*this);
224 }
225
~FormatIntegerIterator()226 FormatIntegerIterator::~FormatIntegerIterator() {}
227
228 // </FormatIntegerIterator>
229
230
231
232 }
233
234
235