SeqAn-1.1/seqan/sequence/string_pointer.h

   1  /*==========================================================================
   2                 SeqAn - The Library for Sequence Analysis
   3                           http://www.seqan.de
   4  ============================================================================
   5   Copyright (C) 2007
   6
   7   This library is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU Lesser General Public
   9   License as published by the Free Software Foundation; either
  10   version 3 of the License, or (at your option) any later version.
  11
  12   This library is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17  ============================================================================
  18   $Id: string_pointer.h,v 1.3 2009/10/12 16:00:57 langmead Exp $
  19  ==========================================================================*/
  20
  21 #ifndef SEQAN_HEADER_SEQUENCE_POINTER_H
  22 #define SEQAN_HEADER_SEQUENCE_POINTER_H
  23
  24 #include <cstring>
  25
  26 namespace SEQAN_NAMESPACE_MAIN
  27 {
  28 //////////////////////////////////////////////////////////////////////////////
  29
  30 /**
  31 .Adaption.char array:
  32 ..summary:Zero terminated $char[]$ or $wchar_t[]$.
  33 ..remarks:Char arrays only support the Insist @Tag.Overflow Strategy.overflow strategy@.
  34 */
  35
  36
  37 //////////////////////////////////////////////////////////////////////////////
  38
  39 /**
  40 .Adaption.char array.remarks:The default overflow strategy
  41 (both @Metafunction.DefaultOverflowImplicit@ and @Metafunction.DefaultOverflowExplicit@)
  42 for all operations on char arrays is @Tag.Overflow Strategy.insist@.
  43 */
  44
  45 template <typename TValue>
  46 struct DefaultOverflowImplicit;
  47
  48 template <typename TValue>
  49 struct DefaultOverflowImplicit< TValue * >
  50 {
  51         typedef Insist Type;
  52 };
  53 template <typename TValue>
  54 struct DefaultOverflowImplicit< TValue * const>
  55 {
  56         typedef Insist Type;
  57 };
  58 template <typename TValue, size_t SIZE>
  59 struct DefaultOverflowImplicit< TValue [SIZE] >
  60 {
  61         typedef Insist Type;
  62 };
  63 template <typename TValue, size_t SIZE>
  64 struct DefaultOverflowImplicit< TValue const [SIZE] >
  65 {
  66         typedef Insist Type;
  67 };
  68 //____________________________________________________________________________
  69
  70 template <typename TValue>
  71 struct DefaultOverflowExplicit;
  72
  73 template <typename TValue>
  74 struct DefaultOverflowExplicit< TValue * >
  75 {
  76         typedef Insist Type;
  77 };
  78 template <typename TValue>
  79 struct DefaultOverflowExplicit< TValue * const>
  80 {
  81         typedef Insist Type;
  82 };
  83 template <typename TValue, size_t SIZE>
  84 struct DefaultOverflowExplicit< TValue [SIZE] >
  85 {
  86         typedef Insist Type;
  87 };
  88 template <typename TValue, size_t SIZE>
  89 struct DefaultOverflowExplicit< TValue const [SIZE] >
  90 {
  91         typedef Insist Type;
  92 };
  93
  94 //////////////////////////////////////////////////////////////////////////////
  95
  96 ///.Metafunction.IsContiguous.param.T.type:Adaption.char array
  97
  98 template <typename TValue>
  99 struct IsContiguous;
 100
 101 template <typename TValue>
 102 struct IsContiguous< TValue * >
 103 {
 104     typedef True Type;
 105         enum { VALUE = true };
 106 };
 107 template <typename TValue, size_t SIZE>
 108 struct IsContiguous< TValue [SIZE] >
 109 {
 110     typedef True Type;
 111         enum { VALUE = true };
 112 };
 113 template <typename TValue, size_t SIZE>
 114 struct IsContiguous< TValue const [SIZE] >
 115 {
 116     typedef True Type;
 117         enum { VALUE = true };
 118 };
 119
 120 /*DISABLED
 121 .Metafunction.IsString.param.T.type:Adaption.char array
 122 */
 123
 124 template <typename TValue>
 125 struct IsSequence< TValue * >
 126 {
 127     typedef True Type;
 128         enum { VALUE = true };
 129 };
 130 template <typename TValue, size_t SIZE>
 131 struct IsSequence< TValue [SIZE] >
 132 {
 133     typedef True Type;
 134         enum { VALUE = true };
 135 };
 136 template <typename TValue, size_t SIZE>
 137 struct IsSequence< TValue const [SIZE] >
 138 {
 139     typedef True Type;
 140         enum { VALUE = true };
 141 };
 142
 143 //////////////////////////////////////////////////////////////////////////////
 144
 145
 146 template <typename T>
 147 inline typename Iterator<T *, typename DefaultGetIteratorSpec<T>::Type>::Type
 148 begin(T * me)
 149 {
 150 SEQAN_CHECKPOINT
 151         return begin(me, typename DefaultGetIteratorSpec<T>::Type()) ;
 152 }
 153
 154 ///.Function.begin.param.object.type:Adaption.char array
 155
 156 template <typename TValue>
 157 inline typename Iterator<TValue *, Standard>::Type
 158 begin(TValue * me,
 159           Standard)
 160 {
 161 SEQAN_CHECKPOINT
 162         return me;
 163 }
 164
 165 //folgende Versionen wurde wegen seltsamer Phaenomene bei VC++ 2003 hinzugenommen
 166 template <typename TValue>
 167 inline typename Iterator<TValue const *, Standard>::Type
 168 begin(TValue const * me,
 169           Standard)
 170 {
 171 SEQAN_CHECKPOINT
 172         return me;
 173 }
 174
 175 template <typename TValue, typename TSpec>
 176 inline typename Iterator<TValue *, Tag<TSpec> const>::Type
 177 begin(TValue * me,
 178           Tag<TSpec> const)
 179 {
 180 SEQAN_CHECKPOINT
 181         typedef typename Iterator<TValue *, Tag<TSpec> const>::Type TIterator;
 182         return TIterator(me, begin(me, Standard()));
 183 }
 184
 185 template <typename TValue, typename TSpec>
 186 inline typename Iterator<TValue const *, Tag<TSpec> const>::Type
 187 begin(TValue const * me,
 188           Tag<TSpec> const)
 189 {
 190 SEQAN_CHECKPOINT
 191         typedef typename Iterator<TValue const *, Tag<TSpec> const>::Type TIterator;
 192         return TIterator(me, begin(me, Standard()));
 193 }
 194
 195 //////////////////////////////////////////////////////////////////////////////
 196
 197 ///.Function.end.param.object.type:Adaption.char array
 198
 199 template <typename TValue>
 200 inline typename Iterator<TValue *, Standard>::Type
 201 end(TValue * me,
 202         Standard)
 203 {
 204 SEQAN_CHECKPOINT
 205         return begin(me, Standard()) + length(me);
 206 }
 207
 208 //folgende Version wurde wegen eines seltsamen Phaenomens bei VC++ hinzugenommen
 209 template <typename TValue>
 210 inline typename Iterator<TValue const *, Standard>::Type
 211 end(TValue const * me,
 212         Standard)
 213 {
 214 SEQAN_CHECKPOINT
 215         return begin(me, Standard()) + length(me);
 216 }
 217
 218 template <typename TValue, typename TSpec>
 219 inline typename Iterator<TValue *, Tag<TSpec> const>::Type
 220 end(TValue * me,
 221           Tag<TSpec> const tag_)
 222 {
 223 SEQAN_CHECKPOINT
 224         return begin(me, tag_) + length(me);
 225 }
 226
 227 template <typename TValue, typename TSpec>
 228 inline typename Iterator<TValue const *, Tag<TSpec> const>::Type
 229 end(TValue const * me,
 230           Tag<TSpec> const tag_)
 231 {
 232 SEQAN_CHECKPOINT
 233         return begin(me, tag_) + length(me);
 234 }
 235
 236
 237 //////////////////////////////////////////////////////////////////////////////
 238
 239 ///.Function.value.param.container.type:Adaption.char array
 240
 241 template <typename TValue, typename TPos>
 242 inline TValue &
 243 value(TValue * me,
 244           TPos pos)
 245 {
 246 SEQAN_CHECKPOINT
 247         return me[pos];
 248 }
 249
 250 template <typename TValue, typename TPos>
 251 inline TValue const &
 252 value(TValue const * me,
 253           TPos pos)
 254 {
 255 SEQAN_CHECKPOINT
 256         return me[pos];
 257 }
 258
 259 //////////////////////////////////////////////////////////////////////////////
 260 // assignValue
 261 //////////////////////////////////////////////////////////////////////////////
 262
 263 template <typename TValue, typename TPos>
 264 inline void
 265 assignValue(TValue * me,
 266                         TPos pos,
 267                         TValue const & _value)
 268 {
 269 SEQAN_CHECKPOINT
 270         assign(value(me, pos), _value);
 271 }
 272
 273 //////////////////////////////////////////////////////////////////////////////
 274 // moveValue
 275 //////////////////////////////////////////////////////////////////////////////
 276
 277 template <typename TValue, typename TPos>
 278 inline void
 279 moveValue(TValue * me,
 280                   TPos pos,
 281                   TValue const & _value)
 282 {
 283 SEQAN_CHECKPOINT
 284         move(value(me, pos), _value);
 285 }
 286
 287 //////////////////////////////////////////////////////////////////////////////
 288
 289 template <typename TValue>
 290 inline bool
 291 atEnd(TValue * pos)
 292 {
 293 SEQAN_CHECKPOINT
 294         return *pos == 0;
 295 }
 296
 297 //____________________________________________________________________________
 298
 299 template <typename TValue>
 300 inline bool
 301 atEnd(TValue * pos,
 302           TValue const * container)
 303 {
 304 SEQAN_CHECKPOINT
 305         return *pos == 0;
 306 }
 307
 308 //////////////////////////////////////////////////////////////////////////////
 309
 310 ///.Function.length.param.object.type:Adaption.char array
 311
 312 template <typename TValue>
 313 inline size_t
 314 length(TValue * me)
 315 {
 316 SEQAN_CHECKPOINT
 317         TValue * it = me;
 318         TValue zero = TValue();
 319         while ( *it != zero) ++it;
 320         return it - me;
 321 }
 322
 323 template <typename TValue>
 324 inline size_t
 325 length(TValue const * me)
 326 {
 327 SEQAN_CHECKPOINT
 328         TValue const * it = me;
 329         TValue const zero = TValue();
 330         while ( *it != zero) ++it;
 331         return it - me;
 332 }
 333
 334 inline size_t
 335 length(char * me)
 336 {
 337 SEQAN_CHECKPOINT
 338         return strlen(me);
 339 }
 340
 341 inline size_t
 342 length(char const * me)
 343 {
 344 SEQAN_CHECKPOINT
 345         return strlen(me);
 346 }
 347
 348 //////////////////////////////////////////////////////////////////////////////
 349
 350 template <typename TValue>
 351 inline void
 352 _setLength(TValue * me,
 353                    size_t new_length)
 354 {
 355 SEQAN_CHECKPOINT
 356         me[new_length] = 0;
 357 }
 358
 359 //////////////////////////////////////////////////////////////////////////////
 360
 361 ///.Function.clear.param.object.type:Adaption.char array
 362
 363 template <typename TValue>
 364 inline void
 365 clear(TValue * me)
 366 {
 367 SEQAN_CHECKPOINT
 368         //arrayDestruct(begin(me), length(me)); //??? Die Laengenbestimmung ist meistens nutzlos, braucht man sowieso nur fuer non-pod
 369         _setLength(me, 0);
 370 }
 371
 372 //////////////////////////////////////////////////////////////////////////////
 373
 374 ///.Function.empty.param.object.type:Adaption.char array
 375
 376 template <typename TValue>
 377 inline bool
 378 empty(TValue * me)
 379 {
 380 SEQAN_CHECKPOINT
 381         return !me || (*me == TValue());
 382 }
 383
 384 //////////////////////////////////////////////////////////////////////////////
 385
 386
 387 template<typename TValue, typename TExpand>
 388 inline size_t
 389 _clearSpace(TValue * me,
 390                    size_t size,
 391                    Tag<TExpand> const)
 392 {
 393 SEQAN_CHECKPOINT
 394         return _ClearSpace_String_Base_<Tag<TExpand> const>::_clearSpace_(me, size);
 395 }
 396
 397 template<typename TValue, typename TExpand>
 398 inline size_t
 399 _clearSpace(TValue * me,
 400                    size_t size,
 401                    size_t limit,
 402                    Tag<TExpand> const)
 403 {
 404 SEQAN_CHECKPOINT
 405         return _ClearSpace_String_Base_<Tag<TExpand> const>::_clearSpace_(me, size, limit);
 406 }
 407
 408 template<typename TValue, typename TPosition, typename TExpand>
 409 inline size_t
 410 _clearSpace(TValue * me,
 411                    size_t size,
 412                    TPosition pos_begin,
 413                    TPosition pos_end,
 414                    Tag<TExpand> const)
 415 {
 416 SEQAN_CHECKPOINT
 417         return _ClearSpace_String_Base_<Tag<TExpand> const>::_clearSpace_(me, size, pos_begin, pos_end);
 418 }
 419
 420 template<typename TValue, typename TPosition, typename TExpand>
 421 inline size_t
 422 _clearSpace(TValue * me,
 423                    size_t size,
 424                    TPosition pos_begin,
 425                    TPosition pos_end,
 426                    size_t limit,
 427                    Tag<TExpand> const)
 428 {
 429 SEQAN_CHECKPOINT
 430         return _ClearSpace_String_Base_<Tag<TExpand> const>::_clearSpace_(me, size, pos_begin, pos_end, limit);
 431 }
 432
 433 //////////////////////////////////////////////////////////////////////////////
 434 // assign
 435 //////////////////////////////////////////////////////////////////////////////
 436
 437 ///.Function.assign.param.target.type:.Adaption.char array
 438 ///.Function.assign.param.source.type:.Adaption.char array
 439
 440 //overload of binary version for strings:
 441
 442 template<typename TTargetValue, typename TSource>
 443 inline void
 444 assign(TTargetValue * target,
 445            TSource & source)
 446 {
 447 SEQAN_CHECKPOINT
 448         typedef TTargetValue * TTarget;
 449         assign(target, source, typename DefaultOverflowImplicit<TTarget>::Type());
 450 }
 451 template<typename TTargetValue, typename TSource>
 452 inline void
 453 assign(TTargetValue * target,
 454            TSource const & source)
 455 {
 456 SEQAN_CHECKPOINT
 457         typedef TTargetValue * TTarget;
 458         assign(target, source, typename DefaultOverflowImplicit<TTarget>::Type());
 459 }
 460
 461 //____________________________________________________________________________
 462
 463 template<typename TTargetValue, typename TSource, typename TExpand>
 464 inline void
 465 assign(TTargetValue * target,
 466            TSource const & source,
 467            Tag<TExpand> const)
 468 {
 469 SEQAN_CHECKPOINT
 470         _Assign_String<Tag<TExpand> const>::assign_(target, source);
 471 }
 472
 473 template<typename TTargetValue, typename TSource, typename TExpand>
 474 inline void
 475 assign(TTargetValue * target,
 476            TSource const & source,
 477            size_t limit,
 478            Tag<TExpand> const)
 479 {
 480 SEQAN_CHECKPOINT
 481         _Assign_String<Tag<TExpand> const>::assign_(target, source, limit);
 482 }
 483
 484 //____________________________________________________________________________
 485 //this variant is a workaround for the "const array"-bug of VC++
 486
 487 template<typename TTargetValue, typename TSourceValue, typename TExpand>
 488 inline void
 489 assign(TTargetValue * target,
 490            TSourceValue const * source,
 491            Tag<TExpand> const)
 492 {
 493 SEQAN_CHECKPOINT
 494         _Assign_String<Tag<TExpand> const>::assign_(target, source);
 495 }
 496
 497 template<typename TTargetValue, typename TSourceValue, typename TExpand>
 498 inline void
 499 assign(TTargetValue * target,
 500            TSourceValue const * source,
 501            size_t limit,
 502            Tag<TExpand> const)
 503 {
 504 SEQAN_CHECKPOINT
 505         _Assign_String<Tag<TExpand> const>::assign_(target, source, limit);
 506 }
 507
 508 //////////////////////////////////////////////////////////////////////////////
 509 // move
 510 //////////////////////////////////////////////////////////////////////////////
 511
 512 //overload of binary version for strings:
 513
 514 template<typename TTargetValue, typename TSource>
 515 inline void
 516 move(TTargetValue * & target,
 517          TSource & source)
 518 {
 519 SEQAN_CHECKPOINT
 520         target = source;
 521 }
 522 template<typename TTargetValue, typename TSource>
 523 inline void
 524 move(TTargetValue * & target,
 525          TSource const & source)
 526 {
 527 SEQAN_CHECKPOINT
 528         target = source;
 529 }
 530
 531
 532 //////////////////////////////////////////////////////////////////////////////
 533 // append
 534 //////////////////////////////////////////////////////////////////////////////
 535
 536 ///.Function.append.param.target.type:.Adaption.char array
 537 ///.Function.append.param.source.type:.Adaption.char array
 538
 539 template<typename TTargetValue, typename TSource, typename TExpand>
 540 inline void
 541 append(TTargetValue * target,
 542            TSource const & source,
 543            Tag<TExpand> const)
 544 {
 545 SEQAN_CHECKPOINT
 546         _Append_String<Tag<TExpand> const>::append_(target, source);
 547 }
 548
 549 template<typename TTargetValue, typename TSource, typename TExpand>
 550 inline void
 551 append(TTargetValue * target,
 552            TSource const & source,
 553            size_t limit,
 554            Tag<TExpand> const)
 555 {
 556 SEQAN_CHECKPOINT
 557         _Append_String<Tag<TExpand> const>::append_(target, source, limit);
 558 }
 559
 560 //____________________________________________________________________________
 561 //this variant is a workaround for the "const array"-bug of VC++
 562
 563 template<typename TTargetValue, typename TSourceValue, typename TExpand>
 564 inline void
 565 append(TTargetValue * target,
 566            TSourceValue const * source,
 567            Tag<TExpand> const)
 568 {
 569 SEQAN_CHECKPOINT
 570         _Append_String<Tag<TExpand> const>::append_(target, source);
 571 }
 572
 573 template<typename TTargetValue, typename TSourceValue, typename TExpand>
 574 inline void
 575 append(TTargetValue * target,
 576            TSourceValue const * source,
 577            size_t limit,
 578            Tag<TExpand> const)
 579 {
 580 SEQAN_CHECKPOINT
 581         _Append_String<Tag<TExpand> const>::append_(target, source, limit);
 582 }
 583
 584 //////////////////////////////////////////////////////////////////////////////
 585 // replace
 586 //////////////////////////////////////////////////////////////////////////////
 587
 588 ///.Function.replace.param.target.type:.Adaption.char array
 589 ///.Function.replace.param.source.type:.Adaption.char array
 590
 591 template<typename TTargetValue, typename TSource, typename TExpand>
 592 inline void
 593 replace(TTargetValue * target,
 594                 size_t pos_begin,
 595                 size_t pos_end,
 596                 TSource const & source,
 597                 Tag<TExpand> const)
 598 {
 599 SEQAN_CHECKPOINT
 600         _Replace_String<Tag<TExpand> const>::replace_(target, pos_begin, pos_end, source);
 601 }
 602
 603 template<typename TTargetValue, typename TSource, typename TExpand>
 604 inline void
 605 replace(TTargetValue * target,
 606                 size_t pos_begin,
 607                 size_t pos_end,
 608                 TSource const & source,
 609                 size_t limit,
 610                 Tag<TExpand> const)
 611 {
 612 SEQAN_CHECKPOINT
 613         _Replace_String<Tag<TExpand> const>::replace_(target, pos_begin, pos_end, source, limit);
 614 }
 615 //____________________________________________________________________________
 616 //this variant is a workaround for the "const array"-bug of VC++
 617
 618 template<typename TTargetValue, typename TSourceValue, typename TExpand>
 619 inline void
 620 replace(TTargetValue * target,
 621                 size_t pos_begin,
 622                 size_t pos_end,
 623                 TSourceValue const * source,
 624                 Tag<TExpand> const)
 625 {
 626 SEQAN_CHECKPOINT
 627         _Replace_String<Tag<TExpand> const>::replace_(target, pos_begin, pos_end, source);
 628 }
 629
 630 template<typename TTargetValue, typename TSourceValue, typename TExpand>
 631 inline void
 632 replace(TTargetValue * target,
 633                 size_t pos_begin,
 634                 size_t pos_end,
 635                 TSourceValue const * source,
 636                 size_t limit,
 637                 Tag<TExpand> const)
 638 {
 639 SEQAN_CHECKPOINT
 640         _Replace_String<Tag<TExpand> const>::replace_(target, pos_begin, pos_end, source, limit);
 641 }
 642
 643 //////////////////////////////////////////////////////////////////////////////
 644 // handling of iterators as begin and and
 645 /*
 646 template<typename TTargetValue, typename TSource, typename TExpand>
 647 inline void
 648 replace(TTargetValue * target,
 649                 typename Iterator<TTargetValue *, Rooted>::Type pos_begin,
 650                 typename Iterator<TTargetValue *, Rooted>::Type pos_end,
 651                 TSource const & source,
 652                 Tag<TExpand> const tag)
 653 {
 654         replace(target, position(pos_begin), position(pos_end), source, tag);
 655 }
 656 template<typename TTargetValue, typename TSource, typename TExpand>
 657 inline void
 658 replace(TTargetValue * target,
 659                 typename Iterator<TTargetValue *, Rooted>::Type pos_begin,
 660                 typename Iterator<TTargetValue *, Rooted>::Type pos_end,
 661                 TSource const & source,
 662                 size_t limit,
 663                 Tag<TExpand> const tag)
 664 {
 665         replace(target, position(pos_begin), position(pos_end), source, limit, tag);
 666 }
 667 */
 668 //////////////////////////////////////////////////////////////////////////////
 669 ///.Function.resize.param.object.type:Adaption.char array
 670
 671 template <typename TValue, typename TExpand>
 672 inline size_t
 673 resize(
 674         TValue * me,
 675         size_t new_length,
 676         Tag<TExpand> const &)
 677 {
 678 SEQAN_CHECKPOINT
 679         return _Resize_String<Tag<TExpand> const>::resize_(me, new_length);
 680 }
 681
 682 //////////////////////////////////////////////////////////////////////////////
 683 ///.Function.fill.param.object.type:Adaption.char array
 684
 685 template <typename TValue, typename TExpand>
 686 inline size_t
 687 fill(
 688         TValue * me,
 689         size_t new_length,
 690         TValue const & val,
 691         Tag<TExpand> const &)
 692 {
 693 SEQAN_CHECKPOINT
 694         return _Fill_String<Tag<TExpand> const>::fill_(me, new_length, val);
 695 }
 696
 697 //////////////////////////////////////////////////////////////////////////////
 698 //PROBLEM: ambiguitiy "pointer/iterator" and "c-style string"
 699 //workaround: disable all operators
 700 /*
 701 template <typename TLeftValue, typename TRight >
 702 TLeftValue const *
 703 operator += (TLeftValue * left,
 704                          TRight const & right)
 705 {
 706 SEQAN_CHECKPOINT
 707         append(left, right);
 708         return left;
 709 }
 710 */
 711 //////////////////////////////////////////////////////////////////////////////
 712
 713 template <typename TLeftValue, typename TRight >
 714 inline bool
 715 isEqual(TLeftValue * left,
 716                 TRight const & right)
 717 {
 718 SEQAN_CHECKPOINT
 719         typename Comparator<TLeftValue *>::Type _lex(left, right);
 720     return isEqual(_lex);
 721 }
 722 /*
 723 template <typename TLeftValue, typename TRight >
 724 inline bool
 725 operator == (TLeftValue * left,
 726                         TRight const & right)
 727 {
 728 SEQAN_CHECKPOINT
 729         typename Comparator<TLeftValue *>::Type _lex(left, right);
 730     return isEqual(_lex);
 731 }
 732 */
 733 //////////////////////////////////////////////////////////////////////////////
 734
 735 template <typename TLeftValue, typename TRight >
 736 inline bool
 737 isNotEqual(TLeftValue * left,
 738                    TRight const & right)
 739 {
 740 SEQAN_CHECKPOINT
 741         typename Comparator<TLeftValue *>::Type _lex(left, right);
 742     return isNotEqual(_lex);
 743 }
 744 /*
 745 template <typename TLeftValue, typename TRight >
 746 inline bool
 747 operator != (TLeftValue * left,
 748                          TRight const & right)
 749 {
 750 SEQAN_CHECKPOINT
 751         typename Comparator<TLeftValue *>::Type _lex(left, right);
 752     return isNotEqual(_lex);
 753 }
 754 */
 755
 756 //////////////////////////////////////////////////////////////////////////////
 757
 758 template <typename TLeftValue, typename TRight>
 759 inline bool
 760 isLess(TLeftValue * left,
 761            TRight const & right)
 762 {
 763 SEQAN_CHECKPOINT
 764         return isLess(left, right, typename DefaultPrefixOrder<TLeftValue *>::Type());
 765 }
 766 /*
 767 template <typename TLeftValue, typename TRight>
 768 inline bool
 769 operator < (TLeftValue * left,
 770                         TRight const & right)
 771 {
 772 SEQAN_CHECKPOINT
 773         return isLess(left, right, typename DefaultPrefixOrder<TLeftValue *>::Type());
 774 }
 775 */
 776 //////////////////////////////////////////////////////////////////////////////
 777
 778 template <typename TLeftValue, typename TRight>
 779 inline bool
 780 isLessOrEqual(TLeftValue * left,
 781                          TRight const & right)
 782 {
 783 SEQAN_CHECKPOINT
 784         return isLessOrEqual(left, right, typename DefaultPrefixOrder<TLeftValue *>::Type());
 785 }
 786 /*
 787 template <typename TLeftValue, typename TRight>
 788 inline bool
 789 operator <= (TLeftValue * left,
 790                          TRight const & right)
 791 {
 792 SEQAN_CHECKPOINT
 793         return isLessOrEqual(left, right, typename DefaultPrefixOrder<TLeftValue *>::Type());
 794 }
 795 */
 796 //////////////////////////////////////////////////////////////////////////////
 797
 798 template <typename TLeftValue, typename TRight>
 799 inline bool
 800 isGreater(TLeftValue * left,
 801                 TRight const & right)
 802 {
 803 SEQAN_CHECKPOINT
 804         return isGreater(left, right, typename DefaultPrefixOrder<TLeftValue *>::Type());
 805 }
 806 /*
 807 template <typename TLeftValue, typename TRight>
 808 inline bool
 809 operator > (TLeftValue * left,
 810                 TRight const & right)
 811 {
 812 SEQAN_CHECKPOINT
 813         return isGreater(left, right, typename DefaultPrefixOrder<TLeftValue *>::Type());
 814 }
 815 */
 816 //////////////////////////////////////////////////////////////////////////////
 817
 818 template <typename TLeftValue, typename TRight>
 819 inline bool
 820 isGreaterOrEqual(TLeftValue * left,
 821                 TRight const & right)
 822 {
 823 SEQAN_CHECKPOINT
 824         return isGreaterOrEqual(left, right, typename DefaultPrefixOrder<TLeftValue *>::Type());
 825 }
 826 /*
 827 template <typename TLeftValue, typename TRight>
 828 inline bool
 829 operator >= (TLeftValue * left,
 830                 TRight const & right)
 831 {
 832 SEQAN_CHECKPOINT
 833         return isGreaterOrEqual(left, right, typename DefaultPrefixOrder<TLeftValue *>::Type());
 834 }
 835 */
 836 //////////////////////////////////////////////////////////////////////////////
 837
 838 } //namespace SEQAN_NAMESPACE_MAIN
 839
 840 //____________________________________________________________________________
 841
 842 #endif //#ifndef SEQAN_HEADER_...