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 #ifndef ZORBA_RUNTIME_CONTEXT_CONTEXT_H
24 #define ZORBA_RUNTIME_CONTEXT_CONTEXT_H
25 
26 
27 #include "common/shared_types.h"
28 
29 
30 
31 #include "runtime/base/narybase.h"
32 
33 
34 namespace zorba {
35 
36 /**
37  * fn:current-dateTime
38  * Author: Zorba Team
39  */
40 class CurrentDateTimeIterator : public NaryBaseIterator<CurrentDateTimeIterator, PlanIteratorState>
41 {
42 public:
43   SERIALIZABLE_CLASS(CurrentDateTimeIterator);
44 
45   SERIALIZABLE_CLASS_CONSTRUCTOR2T(CurrentDateTimeIterator,
46     NaryBaseIterator<CurrentDateTimeIterator, PlanIteratorState>);
47 
48   void serialize( ::zorba::serialization::Archiver& ar);
49 
CurrentDateTimeIterator(static_context * sctx,const QueryLoc & loc,std::vector<PlanIter_t> & children)50   CurrentDateTimeIterator(
51     static_context* sctx,
52     const QueryLoc& loc,
53     std::vector<PlanIter_t>& children)
54     :
55     NaryBaseIterator<CurrentDateTimeIterator, PlanIteratorState>(sctx, loc, children)
56   {}
57 
58   virtual ~CurrentDateTimeIterator();
59 
60   void accept(PlanIterVisitor& v) const;
61 
62   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
63 };
64 
65 
66 /**
67  * fn:current-date
68  * Author: Zorba Team
69  */
70 class CurrentDateIterator : public NaryBaseIterator<CurrentDateIterator, PlanIteratorState>
71 {
72 public:
73   SERIALIZABLE_CLASS(CurrentDateIterator);
74 
75   SERIALIZABLE_CLASS_CONSTRUCTOR2T(CurrentDateIterator,
76     NaryBaseIterator<CurrentDateIterator, PlanIteratorState>);
77 
78   void serialize( ::zorba::serialization::Archiver& ar);
79 
CurrentDateIterator(static_context * sctx,const QueryLoc & loc,std::vector<PlanIter_t> & children)80   CurrentDateIterator(
81     static_context* sctx,
82     const QueryLoc& loc,
83     std::vector<PlanIter_t>& children)
84     :
85     NaryBaseIterator<CurrentDateIterator, PlanIteratorState>(sctx, loc, children)
86   {}
87 
88   virtual ~CurrentDateIterator();
89 
90   void accept(PlanIterVisitor& v) const;
91 
92   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
93 };
94 
95 
96 /**
97  * fn:current-time
98  * Author: Zorba Team
99  */
100 class CurrentTimeIterator : public NaryBaseIterator<CurrentTimeIterator, PlanIteratorState>
101 {
102 public:
103   SERIALIZABLE_CLASS(CurrentTimeIterator);
104 
105   SERIALIZABLE_CLASS_CONSTRUCTOR2T(CurrentTimeIterator,
106     NaryBaseIterator<CurrentTimeIterator, PlanIteratorState>);
107 
108   void serialize( ::zorba::serialization::Archiver& ar);
109 
CurrentTimeIterator(static_context * sctx,const QueryLoc & loc,std::vector<PlanIter_t> & children)110   CurrentTimeIterator(
111     static_context* sctx,
112     const QueryLoc& loc,
113     std::vector<PlanIter_t>& children)
114     :
115     NaryBaseIterator<CurrentTimeIterator, PlanIteratorState>(sctx, loc, children)
116   {}
117 
118   virtual ~CurrentTimeIterator();
119 
120   void accept(PlanIterVisitor& v) const;
121 
122   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
123 };
124 
125 
126 /**
127  * fn:implicit-timezone
128  * Author: Zorba Team
129  */
130 class ImplicitTimezoneIterator : public NaryBaseIterator<ImplicitTimezoneIterator, PlanIteratorState>
131 {
132 public:
133   SERIALIZABLE_CLASS(ImplicitTimezoneIterator);
134 
135   SERIALIZABLE_CLASS_CONSTRUCTOR2T(ImplicitTimezoneIterator,
136     NaryBaseIterator<ImplicitTimezoneIterator, PlanIteratorState>);
137 
138   void serialize( ::zorba::serialization::Archiver& ar);
139 
ImplicitTimezoneIterator(static_context * sctx,const QueryLoc & loc,std::vector<PlanIter_t> & children)140   ImplicitTimezoneIterator(
141     static_context* sctx,
142     const QueryLoc& loc,
143     std::vector<PlanIter_t>& children)
144     :
145     NaryBaseIterator<ImplicitTimezoneIterator, PlanIteratorState>(sctx, loc, children)
146   {}
147 
148   virtual ~ImplicitTimezoneIterator();
149 
150   void accept(PlanIterVisitor& v) const;
151 
152   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
153 };
154 
155 
156 /**
157  * fn:default-collation
158  * Author: Zorba Team
159  */
160 class DefaultCollationIterator : public NaryBaseIterator<DefaultCollationIterator, PlanIteratorState>
161 {
162 public:
163   SERIALIZABLE_CLASS(DefaultCollationIterator);
164 
165   SERIALIZABLE_CLASS_CONSTRUCTOR2T(DefaultCollationIterator,
166     NaryBaseIterator<DefaultCollationIterator, PlanIteratorState>);
167 
168   void serialize( ::zorba::serialization::Archiver& ar);
169 
DefaultCollationIterator(static_context * sctx,const QueryLoc & loc,std::vector<PlanIter_t> & children)170   DefaultCollationIterator(
171     static_context* sctx,
172     const QueryLoc& loc,
173     std::vector<PlanIter_t>& children)
174     :
175     NaryBaseIterator<DefaultCollationIterator, PlanIteratorState>(sctx, loc, children)
176   {}
177 
178   virtual ~DefaultCollationIterator();
179 
180   void accept(PlanIterVisitor& v) const;
181 
182   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
183 };
184 
185 
186 }
187 #endif
188 /*
189  * Local variables:
190  * mode: c++
191  * End:
192  */
193