diff options
Diffstat (limited to 'lib/filter.cpp')
-rw-r--r-- | lib/filter.cpp | 118 |
1 files changed, 59 insertions, 59 deletions
diff --git a/lib/filter.cpp b/lib/filter.cpp index 592b190..e3174ce 100644 --- a/lib/filter.cpp +++ b/lib/filter.cpp | |||
@@ -377,7 +377,7 @@ namespace verbly { | |||
377 | throw std::domain_error("This filter does not have a field"); | 377 | throw std::domain_error("This filter does not have a field"); |
378 | } | 378 | } |
379 | 379 | ||
380 | return mpark::get<singleton_type>(variant_).filterField; | 380 | return std::get<singleton_type>(variant_).filterField; |
381 | } | 381 | } |
382 | 382 | ||
383 | filter::comparison filter::getComparison() const | 383 | filter::comparison filter::getComparison() const |
@@ -387,7 +387,7 @@ namespace verbly { | |||
387 | throw std::domain_error("This filter does not have a comparison"); | 387 | throw std::domain_error("This filter does not have a comparison"); |
388 | } | 388 | } |
389 | 389 | ||
390 | return mpark::get<singleton_type>(variant_).filterType; | 390 | return std::get<singleton_type>(variant_).filterType; |
391 | } | 391 | } |
392 | 392 | ||
393 | filter filter::getJoinCondition() const | 393 | filter filter::getJoinCondition() const |
@@ -397,7 +397,7 @@ namespace verbly { | |||
397 | throw std::domain_error("This filter does not have a join condition"); | 397 | throw std::domain_error("This filter does not have a join condition"); |
398 | } | 398 | } |
399 | 399 | ||
400 | const singleton_type& ss = mpark::get<singleton_type>(variant_); | 400 | const singleton_type& ss = std::get<singleton_type>(variant_); |
401 | 401 | ||
402 | switch (ss.filterType) | 402 | switch (ss.filterType) |
403 | { | 403 | { |
@@ -406,7 +406,7 @@ namespace verbly { | |||
406 | case comparison::hierarchally_matches: | 406 | case comparison::hierarchally_matches: |
407 | case comparison::does_not_hierarchally_match: | 407 | case comparison::does_not_hierarchally_match: |
408 | { | 408 | { |
409 | return *mpark::get<rec_filter>(ss.data); | 409 | return *std::get<rec_filter>(ss.data); |
410 | } | 410 | } |
411 | 411 | ||
412 | case comparison::string_equals: | 412 | case comparison::string_equals: |
@@ -437,7 +437,7 @@ namespace verbly { | |||
437 | throw std::domain_error("This filter does not have a string argument"); | 437 | throw std::domain_error("This filter does not have a string argument"); |
438 | } | 438 | } |
439 | 439 | ||
440 | const singleton_type& ss = mpark::get<singleton_type>(variant_); | 440 | const singleton_type& ss = std::get<singleton_type>(variant_); |
441 | 441 | ||
442 | switch (ss.filterType) | 442 | switch (ss.filterType) |
443 | { | 443 | { |
@@ -446,7 +446,7 @@ namespace verbly { | |||
446 | case comparison::string_is_like: | 446 | case comparison::string_is_like: |
447 | case comparison::string_is_not_like: | 447 | case comparison::string_is_not_like: |
448 | { | 448 | { |
449 | return mpark::get<std::string>(ss.data); | 449 | return std::get<std::string>(ss.data); |
450 | } | 450 | } |
451 | 451 | ||
452 | case comparison::int_equals: | 452 | case comparison::int_equals: |
@@ -477,7 +477,7 @@ namespace verbly { | |||
477 | throw std::domain_error("This filter does not have an integer argument"); | 477 | throw std::domain_error("This filter does not have an integer argument"); |
478 | } | 478 | } |
479 | 479 | ||
480 | const singleton_type& ss = mpark::get<singleton_type>(variant_); | 480 | const singleton_type& ss = std::get<singleton_type>(variant_); |
481 | 481 | ||
482 | switch (ss.filterType) | 482 | switch (ss.filterType) |
483 | { | 483 | { |
@@ -488,7 +488,7 @@ namespace verbly { | |||
488 | case comparison::int_is_at_most: | 488 | case comparison::int_is_at_most: |
489 | case comparison::int_is_less_than: | 489 | case comparison::int_is_less_than: |
490 | { | 490 | { |
491 | return mpark::get<int>(ss.data); | 491 | return std::get<int>(ss.data); |
492 | } | 492 | } |
493 | 493 | ||
494 | case comparison::string_equals: | 494 | case comparison::string_equals: |
@@ -514,13 +514,13 @@ namespace verbly { | |||
514 | bool filter::getBooleanArgument() const | 514 | bool filter::getBooleanArgument() const |
515 | { | 515 | { |
516 | if ((type_ != type::singleton) || | 516 | if ((type_ != type::singleton) || |
517 | (mpark::get<singleton_type>(variant_).filterType != | 517 | (std::get<singleton_type>(variant_).filterType != |
518 | comparison::boolean_equals)) | 518 | comparison::boolean_equals)) |
519 | { | 519 | { |
520 | throw std::domain_error("This filter does not have a boolean argument"); | 520 | throw std::domain_error("This filter does not have a boolean argument"); |
521 | } | 521 | } |
522 | 522 | ||
523 | return mpark::get<bool>(mpark::get<singleton_type>(variant_).data); | 523 | return std::get<bool>(std::get<singleton_type>(variant_).data); |
524 | } | 524 | } |
525 | 525 | ||
526 | field filter::getCompareField() const | 526 | field filter::getCompareField() const |
@@ -530,14 +530,14 @@ namespace verbly { | |||
530 | throw std::domain_error("This filter does not have a compare field"); | 530 | throw std::domain_error("This filter does not have a compare field"); |
531 | } | 531 | } |
532 | 532 | ||
533 | const singleton_type& ss = mpark::get<singleton_type>(variant_); | 533 | const singleton_type& ss = std::get<singleton_type>(variant_); |
534 | 534 | ||
535 | switch (ss.filterType) | 535 | switch (ss.filterType) |
536 | { | 536 | { |
537 | case comparison::field_equals: | 537 | case comparison::field_equals: |
538 | case comparison::field_does_not_equal: | 538 | case comparison::field_does_not_equal: |
539 | { | 539 | { |
540 | return mpark::get<field>(ss.data); | 540 | return std::get<field>(ss.data); |
541 | 541 | ||
542 | break; | 542 | break; |
543 | } | 543 | } |
@@ -579,7 +579,7 @@ namespace verbly { | |||
579 | throw std::domain_error("This filter is not a group filter"); | 579 | throw std::domain_error("This filter is not a group filter"); |
580 | } | 580 | } |
581 | 581 | ||
582 | return mpark::get<group_type>(variant_).orlogic; | 582 | return std::get<group_type>(variant_).orlogic; |
583 | } | 583 | } |
584 | 584 | ||
585 | filter filter::operator+(filter condition) const | 585 | filter filter::operator+(filter condition) const |
@@ -597,7 +597,7 @@ namespace verbly { | |||
597 | throw std::domain_error("Children can only be added to group filters"); | 597 | throw std::domain_error("Children can only be added to group filters"); |
598 | } | 598 | } |
599 | 599 | ||
600 | mpark::get<group_type>(variant_).children.push_back(std::move(condition)); | 600 | std::get<group_type>(variant_).children.push_back(std::move(condition)); |
601 | 601 | ||
602 | return *this; | 602 | return *this; |
603 | } | 603 | } |
@@ -609,7 +609,7 @@ namespace verbly { | |||
609 | throw std::domain_error("This filter has no children"); | 609 | throw std::domain_error("This filter has no children"); |
610 | } | 610 | } |
611 | 611 | ||
612 | return std::begin(mpark::get<group_type>(variant_).children); | 612 | return std::begin(std::get<group_type>(variant_).children); |
613 | } | 613 | } |
614 | 614 | ||
615 | filter::const_iterator filter::end() const | 615 | filter::const_iterator filter::end() const |
@@ -619,7 +619,7 @@ namespace verbly { | |||
619 | throw std::domain_error("This filter has no children"); | 619 | throw std::domain_error("This filter has no children"); |
620 | } | 620 | } |
621 | 621 | ||
622 | return std::end(mpark::get<group_type>(variant_).children); | 622 | return std::end(std::get<group_type>(variant_).children); |
623 | } | 623 | } |
624 | 624 | ||
625 | filter::filter( | 625 | filter::filter( |
@@ -642,7 +642,7 @@ namespace verbly { | |||
642 | throw std::domain_error("This filter is not a mask filter"); | 642 | throw std::domain_error("This filter is not a mask filter"); |
643 | } | 643 | } |
644 | 644 | ||
645 | return mpark::get<mask_type>(variant_).name; | 645 | return std::get<mask_type>(variant_).name; |
646 | } | 646 | } |
647 | 647 | ||
648 | bool filter::isMaskInternal() const | 648 | bool filter::isMaskInternal() const |
@@ -652,7 +652,7 @@ namespace verbly { | |||
652 | throw std::domain_error("This filter is not a mask filter"); | 652 | throw std::domain_error("This filter is not a mask filter"); |
653 | } | 653 | } |
654 | 654 | ||
655 | return mpark::get<mask_type>(variant_).internal; | 655 | return std::get<mask_type>(variant_).internal; |
656 | } | 656 | } |
657 | 657 | ||
658 | const filter& filter::getMaskFilter() const | 658 | const filter& filter::getMaskFilter() const |
@@ -662,7 +662,7 @@ namespace verbly { | |||
662 | throw std::domain_error("This filter is not a mask filter"); | 662 | throw std::domain_error("This filter is not a mask filter"); |
663 | } | 663 | } |
664 | 664 | ||
665 | return *mpark::get<mask_type>(variant_).subfilter; | 665 | return *std::get<mask_type>(variant_).subfilter; |
666 | } | 666 | } |
667 | 667 | ||
668 | filter filter::operator!() const | 668 | filter filter::operator!() const |
@@ -676,7 +676,7 @@ namespace verbly { | |||
676 | 676 | ||
677 | case type::singleton: | 677 | case type::singleton: |
678 | { | 678 | { |
679 | const singleton_type& ss = mpark::get<singleton_type>(variant_); | 679 | const singleton_type& ss = std::get<singleton_type>(variant_); |
680 | 680 | ||
681 | switch (ss.filterType) | 681 | switch (ss.filterType) |
682 | { | 682 | { |
@@ -685,7 +685,7 @@ namespace verbly { | |||
685 | return filter( | 685 | return filter( |
686 | ss.filterField, | 686 | ss.filterField, |
687 | comparison::int_does_not_equal, | 687 | comparison::int_does_not_equal, |
688 | mpark::get<int>(ss.data)); | 688 | std::get<int>(ss.data)); |
689 | } | 689 | } |
690 | 690 | ||
691 | case comparison::int_does_not_equal: | 691 | case comparison::int_does_not_equal: |
@@ -693,7 +693,7 @@ namespace verbly { | |||
693 | return filter( | 693 | return filter( |
694 | ss.filterField, | 694 | ss.filterField, |
695 | comparison::int_equals, | 695 | comparison::int_equals, |
696 | mpark::get<int>(ss.data)); | 696 | std::get<int>(ss.data)); |
697 | } | 697 | } |
698 | 698 | ||
699 | case comparison::int_is_at_least: | 699 | case comparison::int_is_at_least: |
@@ -701,7 +701,7 @@ namespace verbly { | |||
701 | return filter( | 701 | return filter( |
702 | ss.filterField, | 702 | ss.filterField, |
703 | comparison::int_is_less_than, | 703 | comparison::int_is_less_than, |
704 | mpark::get<int>(ss.data)); | 704 | std::get<int>(ss.data)); |
705 | } | 705 | } |
706 | 706 | ||
707 | case comparison::int_is_greater_than: | 707 | case comparison::int_is_greater_than: |
@@ -709,7 +709,7 @@ namespace verbly { | |||
709 | return filter( | 709 | return filter( |
710 | ss.filterField, | 710 | ss.filterField, |
711 | comparison::int_is_at_most, | 711 | comparison::int_is_at_most, |
712 | mpark::get<int>(ss.data)); | 712 | std::get<int>(ss.data)); |
713 | } | 713 | } |
714 | 714 | ||
715 | case comparison::int_is_at_most: | 715 | case comparison::int_is_at_most: |
@@ -717,7 +717,7 @@ namespace verbly { | |||
717 | return filter( | 717 | return filter( |
718 | ss.filterField, | 718 | ss.filterField, |
719 | comparison::int_is_greater_than, | 719 | comparison::int_is_greater_than, |
720 | mpark::get<int>(ss.data)); | 720 | std::get<int>(ss.data)); |
721 | } | 721 | } |
722 | 722 | ||
723 | case comparison::int_is_less_than: | 723 | case comparison::int_is_less_than: |
@@ -725,7 +725,7 @@ namespace verbly { | |||
725 | return filter( | 725 | return filter( |
726 | ss.filterField, | 726 | ss.filterField, |
727 | comparison::int_is_at_least, | 727 | comparison::int_is_at_least, |
728 | mpark::get<int>(ss.data)); | 728 | std::get<int>(ss.data)); |
729 | } | 729 | } |
730 | 730 | ||
731 | case comparison::boolean_equals: | 731 | case comparison::boolean_equals: |
@@ -733,7 +733,7 @@ namespace verbly { | |||
733 | return filter( | 733 | return filter( |
734 | ss.filterField, | 734 | ss.filterField, |
735 | comparison::boolean_equals, | 735 | comparison::boolean_equals, |
736 | !mpark::get<int>(ss.data)); | 736 | !std::get<int>(ss.data)); |
737 | } | 737 | } |
738 | 738 | ||
739 | case comparison::string_equals: | 739 | case comparison::string_equals: |
@@ -741,7 +741,7 @@ namespace verbly { | |||
741 | return filter( | 741 | return filter( |
742 | ss.filterField, | 742 | ss.filterField, |
743 | comparison::string_does_not_equal, | 743 | comparison::string_does_not_equal, |
744 | mpark::get<std::string>(ss.data)); | 744 | std::get<std::string>(ss.data)); |
745 | } | 745 | } |
746 | 746 | ||
747 | case comparison::string_does_not_equal: | 747 | case comparison::string_does_not_equal: |
@@ -749,7 +749,7 @@ namespace verbly { | |||
749 | return filter( | 749 | return filter( |
750 | ss.filterField, | 750 | ss.filterField, |
751 | comparison::string_equals, | 751 | comparison::string_equals, |
752 | mpark::get<std::string>(ss.data)); | 752 | std::get<std::string>(ss.data)); |
753 | } | 753 | } |
754 | 754 | ||
755 | case comparison::string_is_like: | 755 | case comparison::string_is_like: |
@@ -757,7 +757,7 @@ namespace verbly { | |||
757 | return filter( | 757 | return filter( |
758 | ss.filterField, | 758 | ss.filterField, |
759 | comparison::string_is_not_like, | 759 | comparison::string_is_not_like, |
760 | mpark::get<std::string>(ss.data)); | 760 | std::get<std::string>(ss.data)); |
761 | } | 761 | } |
762 | 762 | ||
763 | case comparison::string_is_not_like: | 763 | case comparison::string_is_not_like: |
@@ -765,7 +765,7 @@ namespace verbly { | |||
765 | return filter( | 765 | return filter( |
766 | ss.filterField, | 766 | ss.filterField, |
767 | comparison::string_is_like, | 767 | comparison::string_is_like, |
768 | mpark::get<std::string>(ss.data)); | 768 | std::get<std::string>(ss.data)); |
769 | } | 769 | } |
770 | 770 | ||
771 | case comparison::is_null: | 771 | case comparison::is_null: |
@@ -787,7 +787,7 @@ namespace verbly { | |||
787 | return filter( | 787 | return filter( |
788 | ss.filterField, | 788 | ss.filterField, |
789 | comparison::does_not_match, | 789 | comparison::does_not_match, |
790 | *mpark::get<rec_filter>(ss.data)); | 790 | *std::get<rec_filter>(ss.data)); |
791 | } | 791 | } |
792 | 792 | ||
793 | case comparison::does_not_match: | 793 | case comparison::does_not_match: |
@@ -795,7 +795,7 @@ namespace verbly { | |||
795 | return filter( | 795 | return filter( |
796 | ss.filterField, | 796 | ss.filterField, |
797 | comparison::matches, | 797 | comparison::matches, |
798 | *mpark::get<rec_filter>(ss.data)); | 798 | *std::get<rec_filter>(ss.data)); |
799 | } | 799 | } |
800 | 800 | ||
801 | case comparison::hierarchally_matches: | 801 | case comparison::hierarchally_matches: |
@@ -803,7 +803,7 @@ namespace verbly { | |||
803 | return filter( | 803 | return filter( |
804 | ss.filterField, | 804 | ss.filterField, |
805 | comparison::does_not_hierarchally_match, | 805 | comparison::does_not_hierarchally_match, |
806 | *mpark::get<rec_filter>(ss.data)); | 806 | *std::get<rec_filter>(ss.data)); |
807 | } | 807 | } |
808 | 808 | ||
809 | case comparison::does_not_hierarchally_match: | 809 | case comparison::does_not_hierarchally_match: |
@@ -811,7 +811,7 @@ namespace verbly { | |||
811 | return filter( | 811 | return filter( |
812 | ss.filterField, | 812 | ss.filterField, |
813 | comparison::hierarchally_matches, | 813 | comparison::hierarchally_matches, |
814 | *mpark::get<rec_filter>(ss.data)); | 814 | *std::get<rec_filter>(ss.data)); |
815 | } | 815 | } |
816 | 816 | ||
817 | case comparison::field_equals: | 817 | case comparison::field_equals: |
@@ -819,7 +819,7 @@ namespace verbly { | |||
819 | return filter( | 819 | return filter( |
820 | ss.filterField, | 820 | ss.filterField, |
821 | comparison::field_does_not_equal, | 821 | comparison::field_does_not_equal, |
822 | mpark::get<field>(ss.data)); | 822 | std::get<field>(ss.data)); |
823 | } | 823 | } |
824 | 824 | ||
825 | case comparison::field_does_not_equal: | 825 | case comparison::field_does_not_equal: |
@@ -827,14 +827,14 @@ namespace verbly { | |||
827 | return filter( | 827 | return filter( |
828 | ss.filterField, | 828 | ss.filterField, |
829 | comparison::field_equals, | 829 | comparison::field_equals, |
830 | mpark::get<field>(ss.data)); | 830 | std::get<field>(ss.data)); |
831 | } | 831 | } |
832 | } | 832 | } |
833 | } | 833 | } |
834 | 834 | ||
835 | case type::group: | 835 | case type::group: |
836 | { | 836 | { |
837 | const group_type& gg = mpark::get<group_type>(variant_); | 837 | const group_type& gg = std::get<group_type>(variant_); |
838 | 838 | ||
839 | filter result(!gg.orlogic); | 839 | filter result(!gg.orlogic); |
840 | 840 | ||
@@ -848,7 +848,7 @@ namespace verbly { | |||
848 | 848 | ||
849 | case type::mask: | 849 | case type::mask: |
850 | { | 850 | { |
851 | const mask_type& mm = mpark::get<mask_type>(variant_); | 851 | const mask_type& mm = std::get<mask_type>(variant_); |
852 | 852 | ||
853 | return {mm.name, mm.internal, !*mm.subfilter}; | 853 | return {mm.name, mm.internal, !*mm.subfilter}; |
854 | } | 854 | } |
@@ -879,7 +879,7 @@ namespace verbly { | |||
879 | { | 879 | { |
880 | filter result(false); | 880 | filter result(false); |
881 | 881 | ||
882 | group_type& gg = mpark::get<group_type>(result.variant_); | 882 | group_type& gg = std::get<group_type>(result.variant_); |
883 | 883 | ||
884 | gg.children.push_back(*this); | 884 | gg.children.push_back(*this); |
885 | gg.children.push_back(std::move(condition)); | 885 | gg.children.push_back(std::move(condition)); |
@@ -889,13 +889,13 @@ namespace verbly { | |||
889 | 889 | ||
890 | case type::group: | 890 | case type::group: |
891 | { | 891 | { |
892 | const group_type& og = mpark::get<group_type>(variant_); | 892 | const group_type& og = std::get<group_type>(variant_); |
893 | 893 | ||
894 | if (og.orlogic) | 894 | if (og.orlogic) |
895 | { | 895 | { |
896 | filter result(false); | 896 | filter result(false); |
897 | 897 | ||
898 | group_type& gg = mpark::get<group_type>(result.variant_); | 898 | group_type& gg = std::get<group_type>(result.variant_); |
899 | 899 | ||
900 | gg.children.push_back(*this); | 900 | gg.children.push_back(*this); |
901 | gg.children.push_back(std::move(condition)); | 901 | gg.children.push_back(std::move(condition)); |
@@ -904,7 +904,7 @@ namespace verbly { | |||
904 | } else { | 904 | } else { |
905 | filter result(*this); | 905 | filter result(*this); |
906 | 906 | ||
907 | group_type& gg = mpark::get<group_type>(result.variant_); | 907 | group_type& gg = std::get<group_type>(result.variant_); |
908 | 908 | ||
909 | gg.children.push_back(std::move(condition)); | 909 | gg.children.push_back(std::move(condition)); |
910 | 910 | ||
@@ -928,7 +928,7 @@ namespace verbly { | |||
928 | { | 928 | { |
929 | filter result(true); | 929 | filter result(true); |
930 | 930 | ||
931 | group_type& gg = mpark::get<group_type>(result.variant_); | 931 | group_type& gg = std::get<group_type>(result.variant_); |
932 | 932 | ||
933 | gg.children.push_back(*this); | 933 | gg.children.push_back(*this); |
934 | gg.children.push_back(std::move(condition)); | 934 | gg.children.push_back(std::move(condition)); |
@@ -938,13 +938,13 @@ namespace verbly { | |||
938 | 938 | ||
939 | case type::group: | 939 | case type::group: |
940 | { | 940 | { |
941 | const group_type& og = mpark::get<group_type>(variant_); | 941 | const group_type& og = std::get<group_type>(variant_); |
942 | 942 | ||
943 | if (!og.orlogic) | 943 | if (!og.orlogic) |
944 | { | 944 | { |
945 | filter result(true); | 945 | filter result(true); |
946 | 946 | ||
947 | group_type& gg = mpark::get<group_type>(result.variant_); | 947 | group_type& gg = std::get<group_type>(result.variant_); |
948 | 948 | ||
949 | gg.children.push_back(*this); | 949 | gg.children.push_back(*this); |
950 | gg.children.push_back(std::move(condition)); | 950 | gg.children.push_back(std::move(condition)); |
@@ -953,7 +953,7 @@ namespace verbly { | |||
953 | } else { | 953 | } else { |
954 | filter result(*this); | 954 | filter result(*this); |
955 | 955 | ||
956 | group_type& gg = mpark::get<group_type>(result.variant_); | 956 | group_type& gg = std::get<group_type>(result.variant_); |
957 | 957 | ||
958 | gg.children.push_back(std::move(condition)); | 958 | gg.children.push_back(std::move(condition)); |
959 | 959 | ||
@@ -980,7 +980,7 @@ namespace verbly { | |||
980 | 980 | ||
981 | case type::singleton: | 981 | case type::singleton: |
982 | { | 982 | { |
983 | const singleton_type& ss = mpark::get<singleton_type>(variant_); | 983 | const singleton_type& ss = std::get<singleton_type>(variant_); |
984 | 984 | ||
985 | // First, switch on the normalized context, and then switch on the | 985 | // First, switch on the normalized context, and then switch on the |
986 | // current context. We recursively recontextualize by using the | 986 | // current context. We recursively recontextualize by using the |
@@ -1147,7 +1147,7 @@ namespace verbly { | |||
1147 | 1147 | ||
1148 | case type::group: | 1148 | case type::group: |
1149 | { | 1149 | { |
1150 | const group_type& gg = mpark::get<group_type>(variant_); | 1150 | const group_type& gg = std::get<group_type>(variant_); |
1151 | 1151 | ||
1152 | filter result(gg.orlogic); | 1152 | filter result(gg.orlogic); |
1153 | std::map<field, filter> positiveJoins; | 1153 | std::map<field, filter> positiveJoins; |
@@ -1166,7 +1166,7 @@ namespace verbly { | |||
1166 | case type::singleton: | 1166 | case type::singleton: |
1167 | { | 1167 | { |
1168 | singleton_type& normSing = | 1168 | singleton_type& normSing = |
1169 | mpark::get<singleton_type>(normalized.variant_); | 1169 | std::get<singleton_type>(normalized.variant_); |
1170 | 1170 | ||
1171 | switch (normalized.getComparison()) | 1171 | switch (normalized.getComparison()) |
1172 | { | 1172 | { |
@@ -1178,7 +1178,7 @@ namespace verbly { | |||
1178 | } | 1178 | } |
1179 | 1179 | ||
1180 | positiveJoins.at(normalized.getField()) += | 1180 | positiveJoins.at(normalized.getField()) += |
1181 | std::move(*mpark::get<rec_filter>(normSing.data)); | 1181 | std::move(*std::get<rec_filter>(normSing.data)); |
1182 | 1182 | ||
1183 | break; | 1183 | break; |
1184 | } | 1184 | } |
@@ -1192,7 +1192,7 @@ namespace verbly { | |||
1192 | } | 1192 | } |
1193 | 1193 | ||
1194 | negativeJoins.at(normalized.getField()) += | 1194 | negativeJoins.at(normalized.getField()) += |
1195 | std::move(*mpark::get<rec_filter>(normSing.data)); | 1195 | std::move(*std::get<rec_filter>(normSing.data)); |
1196 | 1196 | ||
1197 | break; | 1197 | break; |
1198 | } | 1198 | } |
@@ -1202,7 +1202,7 @@ namespace verbly { | |||
1202 | if (gg.orlogic) | 1202 | if (gg.orlogic) |
1203 | { | 1203 | { |
1204 | positiveJoins[normalized.getField()] |= | 1204 | positiveJoins[normalized.getField()] |= |
1205 | std::move(*mpark::get<rec_filter>(normSing.data)); | 1205 | std::move(*std::get<rec_filter>(normSing.data)); |
1206 | } else { | 1206 | } else { |
1207 | result += std::move(normalized); | 1207 | result += std::move(normalized); |
1208 | } | 1208 | } |
@@ -1215,7 +1215,7 @@ namespace verbly { | |||
1215 | if (!gg.orlogic) | 1215 | if (!gg.orlogic) |
1216 | { | 1216 | { |
1217 | negativeJoins[normalized.getField()] |= | 1217 | negativeJoins[normalized.getField()] |= |
1218 | std::move(*mpark::get<rec_filter>(normSing.data)); | 1218 | std::move(*std::get<rec_filter>(normSing.data)); |
1219 | } else { | 1219 | } else { |
1220 | result += std::move(normalized); | 1220 | result += std::move(normalized); |
1221 | } | 1221 | } |
@@ -1259,7 +1259,7 @@ namespace verbly { | |||
1259 | case type::mask: | 1259 | case type::mask: |
1260 | { | 1260 | { |
1261 | mask_type& normMask = | 1261 | mask_type& normMask = |
1262 | mpark::get<mask_type>(normalized.variant_); | 1262 | std::get<mask_type>(normalized.variant_); |
1263 | 1263 | ||
1264 | auto maskId = | 1264 | auto maskId = |
1265 | std::tie( | 1265 | std::tie( |
@@ -1310,7 +1310,7 @@ namespace verbly { | |||
1310 | 1310 | ||
1311 | case type::mask: | 1311 | case type::mask: |
1312 | { | 1312 | { |
1313 | const mask_type& mm = mpark::get<mask_type>(variant_); | 1313 | const mask_type& mm = std::get<mask_type>(variant_); |
1314 | 1314 | ||
1315 | return { | 1315 | return { |
1316 | mm.name, | 1316 | mm.name, |
@@ -1333,7 +1333,7 @@ namespace verbly { | |||
1333 | 1333 | ||
1334 | case type::group: | 1334 | case type::group: |
1335 | { | 1335 | { |
1336 | const group_type& gg = mpark::get<group_type>(variant_); | 1336 | const group_type& gg = std::get<group_type>(variant_); |
1337 | 1337 | ||
1338 | filter result(gg.orlogic); | 1338 | filter result(gg.orlogic); |
1339 | for (const filter& child : gg.children) | 1339 | for (const filter& child : gg.children) |
@@ -1345,7 +1345,7 @@ namespace verbly { | |||
1345 | } | 1345 | } |
1346 | } | 1346 | } |
1347 | 1347 | ||
1348 | group_type& resGroup = mpark::get<group_type>(result.variant_); | 1348 | group_type& resGroup = std::get<group_type>(result.variant_); |
1349 | 1349 | ||
1350 | if (resGroup.children.empty()) | 1350 | if (resGroup.children.empty()) |
1351 | { | 1351 | { |
@@ -1362,7 +1362,7 @@ namespace verbly { | |||
1362 | 1362 | ||
1363 | case type::mask: | 1363 | case type::mask: |
1364 | { | 1364 | { |
1365 | const mask_type& mm = mpark::get<mask_type>(variant_); | 1365 | const mask_type& mm = std::get<mask_type>(variant_); |
1366 | 1366 | ||
1367 | filter subfilter = mm.subfilter->compact(); | 1367 | filter subfilter = mm.subfilter->compact(); |
1368 | 1368 | ||