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_MATHS_MATHS_H
24 #define ZORBA_RUNTIME_MATHS_MATHS_H
25 
26 
27 #include "common/shared_types.h"
28 #include "runtime/base/unarybase.h"
29 #include "runtime/base/binarybase.h"
30 #include "runtime/base/noarybase.h"
31 
32 #include "zorbatypes/schema_types.h"
33 
34 
35 namespace zorba {
36 
37 /**
38  * math:sqrt
39  * Author: Zorba Team
40  */
41 class SqrtIterator : public UnaryBaseIterator<SqrtIterator, PlanIteratorState>
42 {
43 public:
44   SERIALIZABLE_CLASS(SqrtIterator);
45 
46   SERIALIZABLE_CLASS_CONSTRUCTOR2T(SqrtIterator,
47     UnaryBaseIterator<SqrtIterator, PlanIteratorState>);
48 
49   void serialize( ::zorba::serialization::Archiver& ar);
50 
SqrtIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)51   SqrtIterator(
52     static_context* sctx,
53     const QueryLoc& loc,
54     PlanIter_t& child)
55     :
56     UnaryBaseIterator<SqrtIterator, PlanIteratorState>(sctx, loc, child)
57   {}
58 
59   virtual ~SqrtIterator();
60 
61   void accept(PlanIterVisitor& v) const;
62 
63   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
64 };
65 
66 
67 /**
68  * math:exp
69  * Author: Zorba Team
70  */
71 class ExpIterator : public UnaryBaseIterator<ExpIterator, PlanIteratorState>
72 {
73 public:
74   SERIALIZABLE_CLASS(ExpIterator);
75 
76   SERIALIZABLE_CLASS_CONSTRUCTOR2T(ExpIterator,
77     UnaryBaseIterator<ExpIterator, PlanIteratorState>);
78 
79   void serialize( ::zorba::serialization::Archiver& ar);
80 
ExpIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)81   ExpIterator(
82     static_context* sctx,
83     const QueryLoc& loc,
84     PlanIter_t& child)
85     :
86     UnaryBaseIterator<ExpIterator, PlanIteratorState>(sctx, loc, child)
87   {}
88 
89   virtual ~ExpIterator();
90 
91   void accept(PlanIterVisitor& v) const;
92 
93   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
94 };
95 
96 
97 /**
98  * math:exp10
99  * Author: Zorba Team
100  */
101 class Exp10Iterator : public UnaryBaseIterator<Exp10Iterator, PlanIteratorState>
102 {
103 public:
104   SERIALIZABLE_CLASS(Exp10Iterator);
105 
106   SERIALIZABLE_CLASS_CONSTRUCTOR2T(Exp10Iterator,
107     UnaryBaseIterator<Exp10Iterator, PlanIteratorState>);
108 
109   void serialize( ::zorba::serialization::Archiver& ar);
110 
Exp10Iterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)111   Exp10Iterator(
112     static_context* sctx,
113     const QueryLoc& loc,
114     PlanIter_t& child)
115     :
116     UnaryBaseIterator<Exp10Iterator, PlanIteratorState>(sctx, loc, child)
117   {}
118 
119   virtual ~Exp10Iterator();
120 
121   void accept(PlanIterVisitor& v) const;
122 
123   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
124 };
125 
126 
127 /**
128  * math:log
129  * Author: Zorba Team
130  */
131 class LogIterator : public UnaryBaseIterator<LogIterator, PlanIteratorState>
132 {
133 public:
134   SERIALIZABLE_CLASS(LogIterator);
135 
136   SERIALIZABLE_CLASS_CONSTRUCTOR2T(LogIterator,
137     UnaryBaseIterator<LogIterator, PlanIteratorState>);
138 
139   void serialize( ::zorba::serialization::Archiver& ar);
140 
LogIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)141   LogIterator(
142     static_context* sctx,
143     const QueryLoc& loc,
144     PlanIter_t& child)
145     :
146     UnaryBaseIterator<LogIterator, PlanIteratorState>(sctx, loc, child)
147   {}
148 
149   virtual ~LogIterator();
150 
151   void accept(PlanIterVisitor& v) const;
152 
153   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
154 };
155 
156 
157 /**
158  * math:log10
159  * Author: Zorba Team
160  */
161 class Log10Iterator : public UnaryBaseIterator<Log10Iterator, PlanIteratorState>
162 {
163 public:
164   SERIALIZABLE_CLASS(Log10Iterator);
165 
166   SERIALIZABLE_CLASS_CONSTRUCTOR2T(Log10Iterator,
167     UnaryBaseIterator<Log10Iterator, PlanIteratorState>);
168 
169   void serialize( ::zorba::serialization::Archiver& ar);
170 
Log10Iterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)171   Log10Iterator(
172     static_context* sctx,
173     const QueryLoc& loc,
174     PlanIter_t& child)
175     :
176     UnaryBaseIterator<Log10Iterator, PlanIteratorState>(sctx, loc, child)
177   {}
178 
179   virtual ~Log10Iterator();
180 
181   void accept(PlanIterVisitor& v) const;
182 
183   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
184 };
185 
186 
187 /**
188  * math:sin
189  * Author: Zorba Team
190  */
191 class SinIterator : public UnaryBaseIterator<SinIterator, PlanIteratorState>
192 {
193 public:
194   SERIALIZABLE_CLASS(SinIterator);
195 
196   SERIALIZABLE_CLASS_CONSTRUCTOR2T(SinIterator,
197     UnaryBaseIterator<SinIterator, PlanIteratorState>);
198 
199   void serialize( ::zorba::serialization::Archiver& ar);
200 
SinIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)201   SinIterator(
202     static_context* sctx,
203     const QueryLoc& loc,
204     PlanIter_t& child)
205     :
206     UnaryBaseIterator<SinIterator, PlanIteratorState>(sctx, loc, child)
207   {}
208 
209   virtual ~SinIterator();
210 
211   void accept(PlanIterVisitor& v) const;
212 
213   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
214 };
215 
216 
217 /**
218  * math:cos
219  * Author: Zorba Team
220  */
221 class CosIterator : public UnaryBaseIterator<CosIterator, PlanIteratorState>
222 {
223 public:
224   SERIALIZABLE_CLASS(CosIterator);
225 
226   SERIALIZABLE_CLASS_CONSTRUCTOR2T(CosIterator,
227     UnaryBaseIterator<CosIterator, PlanIteratorState>);
228 
229   void serialize( ::zorba::serialization::Archiver& ar);
230 
CosIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)231   CosIterator(
232     static_context* sctx,
233     const QueryLoc& loc,
234     PlanIter_t& child)
235     :
236     UnaryBaseIterator<CosIterator, PlanIteratorState>(sctx, loc, child)
237   {}
238 
239   virtual ~CosIterator();
240 
241   void accept(PlanIterVisitor& v) const;
242 
243   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
244 };
245 
246 
247 /**
248  * math:tan
249  * Author: Zorba Team
250  */
251 class TanIterator : public UnaryBaseIterator<TanIterator, PlanIteratorState>
252 {
253 public:
254   SERIALIZABLE_CLASS(TanIterator);
255 
256   SERIALIZABLE_CLASS_CONSTRUCTOR2T(TanIterator,
257     UnaryBaseIterator<TanIterator, PlanIteratorState>);
258 
259   void serialize( ::zorba::serialization::Archiver& ar);
260 
TanIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)261   TanIterator(
262     static_context* sctx,
263     const QueryLoc& loc,
264     PlanIter_t& child)
265     :
266     UnaryBaseIterator<TanIterator, PlanIteratorState>(sctx, loc, child)
267   {}
268 
269   virtual ~TanIterator();
270 
271   void accept(PlanIterVisitor& v) const;
272 
273   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
274 };
275 
276 
277 /**
278  * math:asin
279  * Author: Zorba Team
280  */
281 class ArcSinIterator : public UnaryBaseIterator<ArcSinIterator, PlanIteratorState>
282 {
283 public:
284   SERIALIZABLE_CLASS(ArcSinIterator);
285 
286   SERIALIZABLE_CLASS_CONSTRUCTOR2T(ArcSinIterator,
287     UnaryBaseIterator<ArcSinIterator, PlanIteratorState>);
288 
289   void serialize( ::zorba::serialization::Archiver& ar);
290 
ArcSinIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)291   ArcSinIterator(
292     static_context* sctx,
293     const QueryLoc& loc,
294     PlanIter_t& child)
295     :
296     UnaryBaseIterator<ArcSinIterator, PlanIteratorState>(sctx, loc, child)
297   {}
298 
299   virtual ~ArcSinIterator();
300 
301   void accept(PlanIterVisitor& v) const;
302 
303   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
304 };
305 
306 
307 /**
308  * math:acos
309  * Author: Zorba Team
310  */
311 class ArcCosIterator : public UnaryBaseIterator<ArcCosIterator, PlanIteratorState>
312 {
313 public:
314   SERIALIZABLE_CLASS(ArcCosIterator);
315 
316   SERIALIZABLE_CLASS_CONSTRUCTOR2T(ArcCosIterator,
317     UnaryBaseIterator<ArcCosIterator, PlanIteratorState>);
318 
319   void serialize( ::zorba::serialization::Archiver& ar);
320 
ArcCosIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)321   ArcCosIterator(
322     static_context* sctx,
323     const QueryLoc& loc,
324     PlanIter_t& child)
325     :
326     UnaryBaseIterator<ArcCosIterator, PlanIteratorState>(sctx, loc, child)
327   {}
328 
329   virtual ~ArcCosIterator();
330 
331   void accept(PlanIterVisitor& v) const;
332 
333   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
334 };
335 
336 
337 /**
338  * math:atan
339  * Author: Zorba Team
340  */
341 class ArcTanIterator : public UnaryBaseIterator<ArcTanIterator, PlanIteratorState>
342 {
343 public:
344   SERIALIZABLE_CLASS(ArcTanIterator);
345 
346   SERIALIZABLE_CLASS_CONSTRUCTOR2T(ArcTanIterator,
347     UnaryBaseIterator<ArcTanIterator, PlanIteratorState>);
348 
349   void serialize( ::zorba::serialization::Archiver& ar);
350 
ArcTanIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)351   ArcTanIterator(
352     static_context* sctx,
353     const QueryLoc& loc,
354     PlanIter_t& child)
355     :
356     UnaryBaseIterator<ArcTanIterator, PlanIteratorState>(sctx, loc, child)
357   {}
358 
359   virtual ~ArcTanIterator();
360 
361   void accept(PlanIterVisitor& v) const;
362 
363   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
364 };
365 
366 
367 /**
368  * math:atan2
369  * Author: Zorba Team
370  */
371 class Atan2Iterator : public BinaryBaseIterator<Atan2Iterator, PlanIteratorState>
372 {
373 public:
374   SERIALIZABLE_CLASS(Atan2Iterator);
375 
376   SERIALIZABLE_CLASS_CONSTRUCTOR2T(Atan2Iterator,
377     BinaryBaseIterator<Atan2Iterator, PlanIteratorState>);
378 
379   void serialize( ::zorba::serialization::Archiver& ar);
380 
Atan2Iterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child1,PlanIter_t & child2)381   Atan2Iterator(
382     static_context* sctx,
383     const QueryLoc& loc,
384     PlanIter_t& child1, PlanIter_t& child2)
385     :
386     BinaryBaseIterator<Atan2Iterator, PlanIteratorState>(sctx, loc, child1, child2)
387   {}
388 
389   virtual ~Atan2Iterator();
390 
391   void accept(PlanIterVisitor& v) const;
392 
393   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
394 };
395 
396 
397 /**
398  * zorba-math:cosh
399  * Author: Zorba Team
400  */
401 class CoshIterator : public UnaryBaseIterator<CoshIterator, PlanIteratorState>
402 {
403 public:
404   SERIALIZABLE_CLASS(CoshIterator);
405 
406   SERIALIZABLE_CLASS_CONSTRUCTOR2T(CoshIterator,
407     UnaryBaseIterator<CoshIterator, PlanIteratorState>);
408 
409   void serialize( ::zorba::serialization::Archiver& ar);
410 
CoshIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)411   CoshIterator(
412     static_context* sctx,
413     const QueryLoc& loc,
414     PlanIter_t& child)
415     :
416     UnaryBaseIterator<CoshIterator, PlanIteratorState>(sctx, loc, child)
417   {}
418 
419   virtual ~CoshIterator();
420 
421   void accept(PlanIterVisitor& v) const;
422 
423   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
424 };
425 
426 
427 /**
428  * zorba-math:acosh
429  * Author: Zorba Team
430  */
431 class AcoshIterator : public UnaryBaseIterator<AcoshIterator, PlanIteratorState>
432 {
433 public:
434   SERIALIZABLE_CLASS(AcoshIterator);
435 
436   SERIALIZABLE_CLASS_CONSTRUCTOR2T(AcoshIterator,
437     UnaryBaseIterator<AcoshIterator, PlanIteratorState>);
438 
439   void serialize( ::zorba::serialization::Archiver& ar);
440 
AcoshIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)441   AcoshIterator(
442     static_context* sctx,
443     const QueryLoc& loc,
444     PlanIter_t& child)
445     :
446     UnaryBaseIterator<AcoshIterator, PlanIteratorState>(sctx, loc, child)
447   {}
448 
449   virtual ~AcoshIterator();
450 
451   void accept(PlanIterVisitor& v) const;
452 
453   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
454 };
455 
456 
457 /**
458  * zorba-math:fmod
459  * Author: Zorba Team
460  */
461 class FmodIterator : public BinaryBaseIterator<FmodIterator, PlanIteratorState>
462 {
463 public:
464   SERIALIZABLE_CLASS(FmodIterator);
465 
466   SERIALIZABLE_CLASS_CONSTRUCTOR2T(FmodIterator,
467     BinaryBaseIterator<FmodIterator, PlanIteratorState>);
468 
469   void serialize( ::zorba::serialization::Archiver& ar);
470 
FmodIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child1,PlanIter_t & child2)471   FmodIterator(
472     static_context* sctx,
473     const QueryLoc& loc,
474     PlanIter_t& child1, PlanIter_t& child2)
475     :
476     BinaryBaseIterator<FmodIterator, PlanIteratorState>(sctx, loc, child1, child2)
477   {}
478 
479   virtual ~FmodIterator();
480 
481   void accept(PlanIterVisitor& v) const;
482 
483   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
484 };
485 
486 
487 /**
488  * zorba-math:ldexp
489  * Author: Zorba Team
490  */
491 class LdexpIterator : public BinaryBaseIterator<LdexpIterator, PlanIteratorState>
492 {
493 public:
494   SERIALIZABLE_CLASS(LdexpIterator);
495 
496   SERIALIZABLE_CLASS_CONSTRUCTOR2T(LdexpIterator,
497     BinaryBaseIterator<LdexpIterator, PlanIteratorState>);
498 
499   void serialize( ::zorba::serialization::Archiver& ar);
500 
LdexpIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child1,PlanIter_t & child2)501   LdexpIterator(
502     static_context* sctx,
503     const QueryLoc& loc,
504     PlanIter_t& child1, PlanIter_t& child2)
505     :
506     BinaryBaseIterator<LdexpIterator, PlanIteratorState>(sctx, loc, child1, child2)
507   {}
508 
509   virtual ~LdexpIterator();
510 
511   void accept(PlanIterVisitor& v) const;
512 
513   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
514 };
515 
516 
517 /**
518  * math:pow
519  * Author: Zorba Team
520  */
521 class PowIterator : public BinaryBaseIterator<PowIterator, PlanIteratorState>
522 {
523 public:
524   SERIALIZABLE_CLASS(PowIterator);
525 
526   SERIALIZABLE_CLASS_CONSTRUCTOR2T(PowIterator,
527     BinaryBaseIterator<PowIterator, PlanIteratorState>);
528 
529   void serialize( ::zorba::serialization::Archiver& ar);
530 
PowIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child1,PlanIter_t & child2)531   PowIterator(
532     static_context* sctx,
533     const QueryLoc& loc,
534     PlanIter_t& child1, PlanIter_t& child2)
535     :
536     BinaryBaseIterator<PowIterator, PlanIteratorState>(sctx, loc, child1, child2)
537   {}
538 
539   virtual ~PowIterator();
540 
541   void accept(PlanIterVisitor& v) const;
542 
543   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
544 };
545 
546 
547 /**
548  * zorba-math:sinh
549  * Author: Zorba Team
550  */
551 class SinhIterator : public UnaryBaseIterator<SinhIterator, PlanIteratorState>
552 {
553 public:
554   SERIALIZABLE_CLASS(SinhIterator);
555 
556   SERIALIZABLE_CLASS_CONSTRUCTOR2T(SinhIterator,
557     UnaryBaseIterator<SinhIterator, PlanIteratorState>);
558 
559   void serialize( ::zorba::serialization::Archiver& ar);
560 
SinhIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)561   SinhIterator(
562     static_context* sctx,
563     const QueryLoc& loc,
564     PlanIter_t& child)
565     :
566     UnaryBaseIterator<SinhIterator, PlanIteratorState>(sctx, loc, child)
567   {}
568 
569   virtual ~SinhIterator();
570 
571   void accept(PlanIterVisitor& v) const;
572 
573   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
574 };
575 
576 
577 /**
578  * zorba-math:asinh
579  * Author: Zorba Team
580  */
581 class AsinhIterator : public UnaryBaseIterator<AsinhIterator, PlanIteratorState>
582 {
583 public:
584   SERIALIZABLE_CLASS(AsinhIterator);
585 
586   SERIALIZABLE_CLASS_CONSTRUCTOR2T(AsinhIterator,
587     UnaryBaseIterator<AsinhIterator, PlanIteratorState>);
588 
589   void serialize( ::zorba::serialization::Archiver& ar);
590 
AsinhIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)591   AsinhIterator(
592     static_context* sctx,
593     const QueryLoc& loc,
594     PlanIter_t& child)
595     :
596     UnaryBaseIterator<AsinhIterator, PlanIteratorState>(sctx, loc, child)
597   {}
598 
599   virtual ~AsinhIterator();
600 
601   void accept(PlanIterVisitor& v) const;
602 
603   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
604 };
605 
606 
607 /**
608  * zorba-math:tanh
609  * Author: Zorba Team
610  */
611 class TanhIterator : public UnaryBaseIterator<TanhIterator, PlanIteratorState>
612 {
613 public:
614   SERIALIZABLE_CLASS(TanhIterator);
615 
616   SERIALIZABLE_CLASS_CONSTRUCTOR2T(TanhIterator,
617     UnaryBaseIterator<TanhIterator, PlanIteratorState>);
618 
619   void serialize( ::zorba::serialization::Archiver& ar);
620 
TanhIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)621   TanhIterator(
622     static_context* sctx,
623     const QueryLoc& loc,
624     PlanIter_t& child)
625     :
626     UnaryBaseIterator<TanhIterator, PlanIteratorState>(sctx, loc, child)
627   {}
628 
629   virtual ~TanhIterator();
630 
631   void accept(PlanIterVisitor& v) const;
632 
633   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
634 };
635 
636 
637 /**
638  * zorba-math:atanh
639  * Author: Zorba Team
640  */
641 class AtanhIterator : public UnaryBaseIterator<AtanhIterator, PlanIteratorState>
642 {
643 public:
644   SERIALIZABLE_CLASS(AtanhIterator);
645 
646   SERIALIZABLE_CLASS_CONSTRUCTOR2T(AtanhIterator,
647     UnaryBaseIterator<AtanhIterator, PlanIteratorState>);
648 
649   void serialize( ::zorba::serialization::Archiver& ar);
650 
AtanhIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)651   AtanhIterator(
652     static_context* sctx,
653     const QueryLoc& loc,
654     PlanIter_t& child)
655     :
656     UnaryBaseIterator<AtanhIterator, PlanIteratorState>(sctx, loc, child)
657   {}
658 
659   virtual ~AtanhIterator();
660 
661   void accept(PlanIterVisitor& v) const;
662 
663   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
664 };
665 
666 
667 /**
668  * math:pi
669  * Author: Zorba Team
670  */
671 class PiNumberIterator : public NoaryBaseIterator<PiNumberIterator, PlanIteratorState>
672 {
673 public:
674   SERIALIZABLE_CLASS(PiNumberIterator);
675 
676   SERIALIZABLE_CLASS_CONSTRUCTOR2T(PiNumberIterator,
677     NoaryBaseIterator<PiNumberIterator, PlanIteratorState>);
678 
679   void serialize( ::zorba::serialization::Archiver& ar);
680 
PiNumberIterator(static_context * sctx,const QueryLoc & loc)681   PiNumberIterator(
682     static_context* sctx,
683     const QueryLoc& loc)
684     :
685     NoaryBaseIterator<PiNumberIterator, PlanIteratorState>(sctx, loc)
686   {}
687 
688   virtual ~PiNumberIterator();
689 
690   void accept(PlanIterVisitor& v) const;
691 
692   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
693 };
694 
695 
696 /**
697  * zorba-math:is_inf
698  * Author: Zorba Team
699  */
700 class IsInfIterator : public UnaryBaseIterator<IsInfIterator, PlanIteratorState>
701 {
702 public:
703   SERIALIZABLE_CLASS(IsInfIterator);
704 
705   SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsInfIterator,
706     UnaryBaseIterator<IsInfIterator, PlanIteratorState>);
707 
708   void serialize( ::zorba::serialization::Archiver& ar);
709 
IsInfIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)710   IsInfIterator(
711     static_context* sctx,
712     const QueryLoc& loc,
713     PlanIter_t& child)
714     :
715     UnaryBaseIterator<IsInfIterator, PlanIteratorState>(sctx, loc, child)
716   {}
717 
718   virtual ~IsInfIterator();
719 
720   void accept(PlanIterVisitor& v) const;
721 
722   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
723 };
724 
725 
726 /**
727  * zorba-math:is_nan
728  * Author: Zorba Team
729  */
730 class IsNaNIterator : public UnaryBaseIterator<IsNaNIterator, PlanIteratorState>
731 {
732 public:
733   SERIALIZABLE_CLASS(IsNaNIterator);
734 
735   SERIALIZABLE_CLASS_CONSTRUCTOR2T(IsNaNIterator,
736     UnaryBaseIterator<IsNaNIterator, PlanIteratorState>);
737 
738   void serialize( ::zorba::serialization::Archiver& ar);
739 
IsNaNIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)740   IsNaNIterator(
741     static_context* sctx,
742     const QueryLoc& loc,
743     PlanIter_t& child)
744     :
745     UnaryBaseIterator<IsNaNIterator, PlanIteratorState>(sctx, loc, child)
746   {}
747 
748   virtual ~IsNaNIterator();
749 
750   void accept(PlanIterVisitor& v) const;
751 
752   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
753 };
754 
755 
756 /**
757  * zorba-math:modf
758  * Author: Zorba Team
759  */
760 class ModfIteratorState : public PlanIteratorState
761 {
762 public:
763   xs_double theDoubInteger; //
764 
765   ModfIteratorState();
766 
767   ~ModfIteratorState();
768 
769   void init(PlanState&);
770   void reset(PlanState&);
771 };
772 
773 class ModfIterator : public UnaryBaseIterator<ModfIterator, ModfIteratorState>
774 {
775 public:
776   SERIALIZABLE_CLASS(ModfIterator);
777 
778   SERIALIZABLE_CLASS_CONSTRUCTOR2T(ModfIterator,
779     UnaryBaseIterator<ModfIterator, ModfIteratorState>);
780 
781   void serialize( ::zorba::serialization::Archiver& ar);
782 
ModfIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)783   ModfIterator(
784     static_context* sctx,
785     const QueryLoc& loc,
786     PlanIter_t& child)
787     :
788     UnaryBaseIterator<ModfIterator, ModfIteratorState>(sctx, loc, child)
789   {}
790 
791   virtual ~ModfIterator();
792 
793   void accept(PlanIterVisitor& v) const;
794 
795   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
796 };
797 
798 
799 /**
800  * zorba-math:frexp
801  * Author: Zorba Team
802  */
803 class FrexpIteratorState : public PlanIteratorState
804 {
805 public:
806   xs_integer theIntExponent; //
807 
808   FrexpIteratorState();
809 
810   ~FrexpIteratorState();
811 
812   void init(PlanState&);
813   void reset(PlanState&);
814 };
815 
816 class FrexpIterator : public UnaryBaseIterator<FrexpIterator, FrexpIteratorState>
817 {
818 public:
819   SERIALIZABLE_CLASS(FrexpIterator);
820 
821   SERIALIZABLE_CLASS_CONSTRUCTOR2T(FrexpIterator,
822     UnaryBaseIterator<FrexpIterator, FrexpIteratorState>);
823 
824   void serialize( ::zorba::serialization::Archiver& ar);
825 
FrexpIterator(static_context * sctx,const QueryLoc & loc,PlanIter_t & child)826   FrexpIterator(
827     static_context* sctx,
828     const QueryLoc& loc,
829     PlanIter_t& child)
830     :
831     UnaryBaseIterator<FrexpIterator, FrexpIteratorState>(sctx, loc, child)
832   {}
833 
834   virtual ~FrexpIterator();
835 
836   void accept(PlanIterVisitor& v) const;
837 
838   bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
839 };
840 
841 
842 }
843 #endif
844 /*
845  * Local variables:
846  * mode: c++
847  * End:
848  */
849