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_FETCH_FETCH_H 24 #define ZORBA_RUNTIME_FETCH_FETCH_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 * 38 * Author: Matthias Brantner 39 */ 40 class FetchContentIterator : public NaryBaseIterator<FetchContentIterator, PlanIteratorState> 41 { 42 public: 43 SERIALIZABLE_CLASS(FetchContentIterator); 44 45 SERIALIZABLE_CLASS_CONSTRUCTOR2T(FetchContentIterator, 46 NaryBaseIterator<FetchContentIterator, PlanIteratorState>); 47 48 void serialize( ::zorba::serialization::Archiver& ar); 49 FetchContentIterator(static_context * sctx,const QueryLoc & loc,std::vector<PlanIter_t> & children)50 FetchContentIterator( 51 static_context* sctx, 52 const QueryLoc& loc, 53 std::vector<PlanIter_t>& children) 54 : 55 NaryBaseIterator<FetchContentIterator, PlanIteratorState>(sctx, loc, children) 56 {} 57 58 virtual ~FetchContentIterator(); 59 60 public: 61 static void destroyStream(std::istream& aStream); 62 void accept(PlanIterVisitor& v) const; 63 64 bool nextImpl(store::Item_t& result, PlanState& aPlanState) const; 65 }; 66 67 68 /** 69 * 70 * Author: Matthias Brantner 71 */ 72 class FetchContentBinaryIterator : public NaryBaseIterator<FetchContentBinaryIterator, PlanIteratorState> 73 { 74 public: 75 SERIALIZABLE_CLASS(FetchContentBinaryIterator); 76 77 SERIALIZABLE_CLASS_CONSTRUCTOR2T(FetchContentBinaryIterator, 78 NaryBaseIterator<FetchContentBinaryIterator, PlanIteratorState>); 79 80 void serialize( ::zorba::serialization::Archiver& ar); 81 FetchContentBinaryIterator(static_context * sctx,const QueryLoc & loc,std::vector<PlanIter_t> & children)82 FetchContentBinaryIterator( 83 static_context* sctx, 84 const QueryLoc& loc, 85 std::vector<PlanIter_t>& children) 86 : 87 NaryBaseIterator<FetchContentBinaryIterator, PlanIteratorState>(sctx, loc, children) 88 {} 89 90 virtual ~FetchContentBinaryIterator(); 91 92 public: 93 static void destroyStream(std::istream& aStream); 94 void accept(PlanIterVisitor& v) const; 95 96 bool nextImpl(store::Item_t& result, PlanState& aPlanState) const; 97 }; 98 99 100 /** 101 * 102 * Author: Matthias Brantner 103 */ 104 class FetchContentTypeIterator : public NaryBaseIterator<FetchContentTypeIterator, PlanIteratorState> 105 { 106 public: 107 SERIALIZABLE_CLASS(FetchContentTypeIterator); 108 109 SERIALIZABLE_CLASS_CONSTRUCTOR2T(FetchContentTypeIterator, 110 NaryBaseIterator<FetchContentTypeIterator, PlanIteratorState>); 111 112 void serialize( ::zorba::serialization::Archiver& ar); 113 FetchContentTypeIterator(static_context * sctx,const QueryLoc & loc,std::vector<PlanIter_t> & children)114 FetchContentTypeIterator( 115 static_context* sctx, 116 const QueryLoc& loc, 117 std::vector<PlanIter_t>& children) 118 : 119 NaryBaseIterator<FetchContentTypeIterator, PlanIteratorState>(sctx, loc, children) 120 {} 121 122 virtual ~FetchContentTypeIterator(); 123 124 void accept(PlanIterVisitor& v) const; 125 126 bool nextImpl(store::Item_t& result, PlanState& aPlanState) const; 127 }; 128 129 130 } 131 #endif 132 /* 133 * Local variables: 134 * mode: c++ 135 * End: 136 */ 137