← Back to branch summary

~zorba-coders/zorba/bug1123016

« back to all changes in this revision

Viewing changes to src/runtime/hof/pregenerated/fn_hof_functions.cpp

  • Committer: Sorin Marian Nasoi
  • Date: 2013-04-09 11:44:43 UTC
  • mfrom: (11301.1.53 zorba)
  • Revision ID: spungi@gmail.com-20130409114443-89vz57gpyjzwoiok
Merged lp:zorba trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/runtime/hof/pregenerated/fn_hof_functions.cpp
 
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/hof/fn_hof_functions.h"
 
29
#include "system/globalenv.h"
 
30
 
 
31
 
 
32
#include "context/static_context.h"
 
33
#include "compiler/api/compilercb.h"
 
34
#include "context/dynamic_context.h"
 
35
#include "store/api/temp_seq.h"
 
36
 
 
37
namespace zorba {
 
38
 
 
39
// <FunctionLookupIterator>
 
40
SERIALIZABLE_CLASS_VERSIONS(FunctionLookupIterator)
 
41
 
 
42
void FunctionLookupIterator::serialize(::zorba::serialization::Archiver& ar)
 
43
{
 
44
  serialize_baseclass(ar,
 
45
  (NaryBaseIterator<FunctionLookupIterator, PlanIteratorState>*)this);
 
46
 
 
47
    ar & theCompilerCB;
 
48
}
 
49
 
 
50
 
 
51
void FunctionLookupIterator::accept(PlanIterVisitor& v) const
 
52
{
 
53
  v.beginVisit(*this);
 
54
 
 
55
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
 
56
  std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
 
57
  for ( ; lIter != lEnd; ++lIter ){
 
58
    (*lIter)->accept(v);
 
59
  }
 
60
 
 
61
  v.endVisit(*this);
 
62
}
 
63
 
 
64
FunctionLookupIterator::~FunctionLookupIterator() {}
 
65
 
 
66
// </FunctionLookupIterator>
 
67
 
 
68
 
 
69
// <FunctionNameIterator>
 
70
SERIALIZABLE_CLASS_VERSIONS(FunctionNameIterator)
 
71
 
 
72
void FunctionNameIterator::serialize(::zorba::serialization::Archiver& ar)
 
73
{
 
74
  serialize_baseclass(ar,
 
75
  (NaryBaseIterator<FunctionNameIterator, PlanIteratorState>*)this);
 
76
}
 
77
 
 
78
 
 
79
void FunctionNameIterator::accept(PlanIterVisitor& v) const
 
80
{
 
81
  v.beginVisit(*this);
 
82
 
 
83
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
 
84
  std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
 
85
  for ( ; lIter != lEnd; ++lIter ){
 
86
    (*lIter)->accept(v);
 
87
  }
 
88
 
 
89
  v.endVisit(*this);
 
90
}
 
91
 
 
92
FunctionNameIterator::~FunctionNameIterator() {}
 
93
 
 
94
// </FunctionNameIterator>
 
95
 
 
96
 
 
97
// <FunctionArityIterator>
 
98
SERIALIZABLE_CLASS_VERSIONS(FunctionArityIterator)
 
99
 
 
100
void FunctionArityIterator::serialize(::zorba::serialization::Archiver& ar)
 
101
{
 
102
  serialize_baseclass(ar,
 
103
  (NaryBaseIterator<FunctionArityIterator, PlanIteratorState>*)this);
 
104
}
 
105
 
 
106
 
 
107
void FunctionArityIterator::accept(PlanIterVisitor& v) const
 
108
{
 
109
  v.beginVisit(*this);
 
110
 
 
111
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
 
112
  std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
 
113
  for ( ; lIter != lEnd; ++lIter ){
 
114
    (*lIter)->accept(v);
 
115
  }
 
116
 
 
117
  v.endVisit(*this);
 
118
}
 
119
 
 
120
FunctionArityIterator::~FunctionArityIterator() {}
 
121
 
 
122
// </FunctionArityIterator>
 
123
 
 
124
 
 
125
// <FnMapPairsIterator>
 
126
SERIALIZABLE_CLASS_VERSIONS(FnMapPairsIterator)
 
127
 
 
128
void FnMapPairsIterator::serialize(::zorba::serialization::Archiver& ar)
 
129
{
 
130
  serialize_baseclass(ar,
 
131
  (NaryBaseIterator<FnMapPairsIterator, FnMapPairsIteratorState>*)this);
 
132
}
 
133
 
 
134
 
 
135
void FnMapPairsIterator::accept(PlanIterVisitor& v) const
 
136
{
 
137
  v.beginVisit(*this);
 
138
 
 
139
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
 
140
  std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
 
141
  for ( ; lIter != lEnd; ++lIter ){
 
142
    (*lIter)->accept(v);
 
143
  }
 
144
 
 
145
  v.endVisit(*this);
 
146
}
 
147
 
 
148
FnMapPairsIterator::~FnMapPairsIterator() {}
 
149
 
 
150
FnMapPairsIteratorState::FnMapPairsIteratorState() {}
 
151
 
 
152
// </FnMapPairsIterator>
 
153
 
 
154
 
 
155
// <FnFoldLeftIterator>
 
156
SERIALIZABLE_CLASS_VERSIONS(FnFoldLeftIterator)
 
157
 
 
158
void FnFoldLeftIterator::serialize(::zorba::serialization::Archiver& ar)
 
159
{
 
160
  serialize_baseclass(ar,
 
161
  (NaryBaseIterator<FnFoldLeftIterator, FnFoldLeftIteratorState>*)this);
 
162
 
 
163
    ar & theIsFoldRight;
 
164
}
 
165
 
 
166
 
 
167
void FnFoldLeftIterator::accept(PlanIterVisitor& v) const
 
168
{
 
169
  v.beginVisit(*this);
 
170
 
 
171
  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
 
172
  std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
 
173
  for ( ; lIter != lEnd; ++lIter ){
 
174
    (*lIter)->accept(v);
 
175
  }
 
176
 
 
177
  v.endVisit(*this);
 
178
}
 
179
 
 
180
FnFoldLeftIterator::~FnFoldLeftIterator() {}
 
181
 
 
182
FnFoldLeftIteratorState::FnFoldLeftIteratorState() {}
 
183
 
 
184
// </FnFoldLeftIterator>
 
185
 
 
186
 
 
187
 
 
188
}
 
189
 
 
190