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