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