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