visus
/
dds
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
195 Commits
6 Branches
Tree: 642bd218b5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '642bd218b5'
${ noResults }
dds/external/ranges-v3/include/range/v3/view/set_algorithm.hpp

793 lines
29KB
Raw Blame History 

  1. /// \file

  2. // Range v3 library

  3. //

  4. //  Copyright Eric Niebler 2013-present

  5. //  Copyright Tomislav Ivek 2015-2016

  6. //

  7. //  Use, modification and distribution is subject to the

  8. //  Boost Software License, Version 1.0. (See accompanying

  9. //  file LICENSE_1_0.txt or copy at

  10. //  http://www.boost.org/LICENSE_1_0.txt)

  11. //

  12. // Project home: https://github.com/ericniebler/range-v3

  13. //

  14. 

  15. #ifndef RANGES_V3_VIEW_SET_ALGORITHM_HPP

  16. #define RANGES_V3_VIEW_SET_ALGORITHM_HPP

  17. 

  18. #include <algorithm>

  19. #include <iterator>

  20. #include <type_traits>

  21. #include <utility>

  22. 

  23. #include <meta/meta.hpp>

  24. 

  25. #include <range/v3/range_fwd.hpp>

  26. 

  27. #include <range/v3/functional/comparisons.hpp>

  28. #include <range/v3/functional/identity.hpp>

  29. #include <range/v3/functional/invoke.hpp>

  30. #include <range/v3/iterator/default_sentinel.hpp>

  31. #include <range/v3/range/access.hpp>

  32. #include <range/v3/range/primitives.hpp>

  33. #include <range/v3/range/traits.hpp>

  34. #include <range/v3/utility/move.hpp>

  35. #include <range/v3/utility/semiregular_box.hpp>

  36. #include <range/v3/utility/static_const.hpp>

  37. #include <range/v3/view/all.hpp>

  38. #include <range/v3/view/facade.hpp>

  39. #include <range/v3/view/view.hpp>

  40. 

  41. namespace ranges

  42. {

  43.     /// \cond

  44.     namespace detail

  45.     {

  46.         template<typename Rng1, typename Rng2, typename C, typename P1, typename P2,

  47.                  template<bool, typename...> class Cursor, cardinality Cardinality>

  48.         struct set_algorithm_view

  49.           : view_facade<set_algorithm_view<Rng1, Rng2, C, P1, P2, Cursor, Cardinality>,

  50.                         Cardinality>

  51.         {

  52.         private:

  53.             friend range_access;

  54.             semiregular_box_t<C> pred_;

  55.             semiregular_box_t<P1> proj1_;

  56.             semiregular_box_t<P2> proj2_;

  57.             Rng1 rng1_;

  58.             Rng2 rng2_;

  59. 

  60.             template<bool IsConst>

  61.             using cursor = Cursor<IsConst, Rng1, Rng2, C, P1, P2>;

  62. 

  63.             cursor<simple_view<Rng1>() && simple_view<Rng2>()> begin_cursor()

  64.             {

  65.                 return {pred_,

  66.                         proj1_,

  67.                         proj2_,

  68.                         ranges::begin(rng1_),

  69.                         ranges::end(rng1_),

  70.                         ranges::begin(rng2_),

  71.                         ranges::end(rng2_)};

  72.             }

  73.             CPP_member

  74.             auto begin_cursor() const -> CPP_ret(cursor<true>)( //

  75.                 requires range<Rng1 const> && range<Rng2 const>)

  76.             {

  77.                 return {pred_,

  78.                         proj1_,

  79.                         proj2_,

  80.                         ranges::begin(rng1_),

  81.                         ranges::end(rng1_),

  82.                         ranges::begin(rng2_),

  83.                         ranges::end(rng2_)};

  84.             }

  85. 

  86.         public:

  87.             set_algorithm_view() = default;

  88.             set_algorithm_view(Rng1 rng1, Rng2 rng2, C pred, P1 proj1, P2 proj2)

  89.               : pred_(std::move(pred))

  90.               , proj1_(std::move(proj1))

  91.               , proj2_(std::move(proj2))

  92.               , rng1_(std::move(rng1))

  93.               , rng2_(std::move(rng2))

  94.             {}

  95.         };

  96. 

  97.         template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,

  98.                  typename P2>

  99.         struct set_difference_cursor

  100.         {

  101.         private:

  102.             friend struct set_difference_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;

  103.             using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;

  104.             using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;

  105.             using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;

  106.             pred_ref_ pred_;

  107.             proj1_ref_ proj1_;

  108.             proj2_ref_ proj2_;

  109. 

  110.             template<typename T>

  111.             using constify_if = meta::const_if_c<IsConst, T>;

  112. 

  113.             using R1 = constify_if<Rng1>;

  114.             using R2 = constify_if<Rng2>;

  115. 

  116.             iterator_t<R1> it1_;

  117.             sentinel_t<R1> end1_;

  118. 

  119.             iterator_t<R2> it2_;

  120.             sentinel_t<R2> end2_;

  121. 

  122.             void satisfy()

  123.             {

  124.                 while(it1_ != end1_)

  125.                 {

  126.                     if(it2_ == end2_)

  127.                         return;

  128. 

  129.                     if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))

  130.                         return;

  131. 

  132.                     if(!invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))

  133.                         ++it1_;

  134. 

  135.                     ++it2_;

  136.                 }

  137.             }

  138. 

  139.         public:

  140.             using value_type = range_value_t<constify_if<Rng1>>;

  141.             using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,

  142.                                            single_pass_iterator_<iterator_t<R2>>>;

  143. 

  144.             set_difference_cursor() = default;

  145.             set_difference_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,

  146.                                   iterator_t<R1> it1, sentinel_t<R1> end1,

  147.                                   iterator_t<R2> it2, sentinel_t<R2> end2)

  148.               : pred_(std::move(pred))

  149.               , proj1_(std::move(proj1))

  150.               , proj2_(std::move(proj2))

  151.               , it1_(std::move(it1))

  152.               , end1_(std::move(end1))

  153.               , it2_(std::move(it2))

  154.               , end2_(std::move(end2))

  155.             {

  156.                 satisfy();

  157.             }

  158.             CPP_template(bool Other)(         //

  159.                 requires IsConst && (!Other)) //

  160.                 set_difference_cursor(

  161.                     set_difference_cursor<Other, Rng1, Rng2, C, P1, P2> that)

  162.               : pred_(std::move(that.pred_))

  163.               , proj1_(std::move(that.proj1_))

  164.               , proj2_(std::move(that.proj2_))

  165.               , it1_(std::move(that.it1_))

  166.               , end1_(std::move(that.end1_))

  167.               , it2_(std::move(that.it2_))

  168.               , end2_(std::move(that.end2_))

  169.             {}

  170.             // clang-format off

  171.             auto CPP_auto_fun(read)()(const)

  172.             (

  173.                 return *it1_

  174.             )

  175.                 // clang-format on

  176.                 void next()

  177.             {

  178.                 ++it1_;

  179.                 satisfy();

  180.             }

  181.             CPP_member

  182.             auto equal(set_difference_cursor const & that) const -> CPP_ret(bool)( //

  183.                 requires forward_range<Rng1>)

  184.             {

  185.                 // does not support comparing iterators from different ranges

  186.                 return it1_ == that.it1_;

  187.             }

  188.             bool equal(default_sentinel_t) const

  189.             {

  190.                 return it1_ == end1_;

  191.             }

  192.             // clang-format off

  193.             auto CPP_auto_fun(move)()(const)

  194.             (

  195.                 return iter_move(it1_)

  196.             )

  197.             // clang-format on

  198.         };

  199. 

  200.         constexpr cardinality set_difference_cardinality(cardinality c1, cardinality c2)

  201.         {

  202.             return (c1 == unknown)

  203.                        ? unknown

  204.                        : (c1 >= 0) || (c1 == finite) ? finite : // else, c1 == infinite

  205.                              (c2 >= 0) || (c2 == finite) ? infinite : unknown;

  206.         }

  207.     } // namespace detail

  208.     /// \endcond

  209. 

  210.     template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>

  211.     using set_difference_view =

  212.         detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_difference_cursor,

  213.                                    detail::set_difference_cardinality(

  214.                                        range_cardinality<Rng1>::value,

  215.                                        range_cardinality<Rng2>::value)>;

  216. 

  217.     namespace views

  218.     {

  219.         struct set_difference_fn

  220.         {

  221.         public:

  222.             template<typename Rng1, typename Rng2, typename C = less,

  223.                      typename P1 = identity, typename P2 = identity>

  224.             auto operator()(Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{},

  225.                             P2 proj2 = P2{}) const

  226.                 -> CPP_ret(set_difference_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2>)( //

  227.                     requires viewable_range<Rng1> && input_range<Rng1> &&

  228.                         viewable_range<Rng2> && input_range<Rng2> &&

  229.                             indirect_relation<C, projected<iterator_t<Rng1>, P1>,

  230.                                               projected<iterator_t<Rng2>, P2>>)

  231.             {

  232.                 return {all(static_cast<Rng1 &&>(rng1)),

  233.                         all(static_cast<Rng2 &&>(rng2)),

  234.                         std::move(pred),

  235.                         std::move(proj1),

  236.                         std::move(proj2)};

  237.             }

  238.         };

  239. 

  240.         /// \relates set_difference_fn

  241.         /// \ingroup group-views

  242.         RANGES_INLINE_VARIABLE(view<set_difference_fn>, set_difference)

  243.     } // namespace views

  244.     /// @}

  245. 

  246.     /// \cond

  247.     namespace detail

  248.     {

  249.         template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,

  250.                  typename P2>

  251.         struct set_intersection_cursor

  252.         {

  253.         private:

  254.             friend struct set_intersection_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;

  255.             using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;

  256.             using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;

  257.             using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;

  258.             pred_ref_ pred_;

  259.             proj1_ref_ proj1_;

  260.             proj2_ref_ proj2_;

  261. 

  262.             template<typename T>

  263.             using constify_if = meta::const_if_c<IsConst, T>;

  264. 

  265.             using R1 = constify_if<Rng1>;

  266.             using R2 = constify_if<Rng2>;

  267. 

  268.             iterator_t<R1> it1_;

  269.             sentinel_t<R1> end1_;

  270. 

  271.             iterator_t<R2> it2_;

  272.             sentinel_t<R2> end2_;

  273. 

  274.             void satisfy()

  275.             {

  276.                 while(it1_ != end1_ && it2_ != end2_)

  277.                 {

  278.                     if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))

  279.                         ++it1_;

  280.                     else

  281.                     {

  282.                         if(!invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))

  283.                             return;

  284.                         ++it2_;

  285.                     }

  286.                 }

  287.             }

  288. 

  289.         public:

  290.             using value_type = range_value_t<R1>;

  291.             using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,

  292.                                            single_pass_iterator_<iterator_t<R2>>>;

  293. 

  294.             set_intersection_cursor() = default;

  295.             set_intersection_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,

  296.                                     iterator_t<R1> it1, sentinel_t<R1> end1,

  297.                                     iterator_t<R2> it2, sentinel_t<R2> end2)

  298.               : pred_(std::move(pred))

  299.               , proj1_(std::move(proj1))

  300.               , proj2_(std::move(proj2))

  301.               , it1_(std::move(it1))

  302.               , end1_(std::move(end1))

  303.               , it2_(std::move(it2))

  304.               , end2_(std::move(end2))

  305.             {

  306.                 satisfy();

  307.             }

  308.             CPP_template(bool Other)(         //

  309.                 requires IsConst && (!Other)) //

  310.                 set_intersection_cursor(

  311.                     set_intersection_cursor<Other, Rng1, Rng2, C, P1, P2> that)

  312.               : pred_(std::move(that.pred_))

  313.               , proj1_(std::move(that.proj1_))

  314.               , proj2_(std::move(that.proj2_))

  315.               , it1_(std::move(that.it1_))

  316.               , end1_(std::move(that.end1_))

  317.               , it2_(std::move(that.it2_))

  318.               , end2_(std::move(that.end2_))

  319.             {}

  320.             // clang-format off

  321.             auto CPP_auto_fun(read)()(const)

  322.             (

  323.                 return *it1_

  324.             )

  325.                 // clang-format on

  326.                 void next()

  327.             {

  328.                 ++it1_;

  329.                 ++it2_;

  330.                 satisfy();

  331.             }

  332.             CPP_member

  333.             auto equal(set_intersection_cursor const & that) const -> CPP_ret(bool)( //

  334.                 requires forward_range<Rng1>)

  335.             {

  336.                 // does not support comparing iterators from different ranges

  337.                 return it1_ == that.it1_;

  338.             }

  339.             bool equal(default_sentinel_t) const

  340.             {

  341.                 return (it1_ == end1_) || (it2_ == end2_);

  342.             }

  343.             // clang-format off

  344.             auto CPP_auto_fun(move)()(const)

  345.             (

  346.                 return iter_move(it1_)

  347.             )

  348.             // clang-format on

  349.         };

  350. 

  351.         constexpr cardinality set_intersection_cardinality(cardinality c1, cardinality c2)

  352.         {

  353.             return (c1 == unknown) || (c2 == unknown)

  354.                        ? unknown

  355.                        : (c1 >= 0 || c1 == finite) || (c2 >= 0 || c2 == finite) ? finite

  356.                                                                                 : unknown;

  357.         }

  358.     } // namespace detail

  359.     /// \endcond

  360. 

  361.     template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>

  362.     using set_intersection_view =

  363.         detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_intersection_cursor,

  364.                                    detail::set_intersection_cardinality(

  365.                                        range_cardinality<Rng1>::value,

  366.                                        range_cardinality<Rng2>::value)>;

  367. 

  368.     namespace views

  369.     {

  370.         struct set_intersection_fn

  371.         {

  372.         public:

  373.             template<typename Rng1, typename Rng2, typename C = less,

  374.                      typename P1 = identity, typename P2 = identity>

  375.             auto operator()(Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{},

  376.                             P2 proj2 = P2{}) const

  377.                 -> CPP_ret(set_intersection_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2>)( //

  378.                     requires viewable_range<Rng1> && input_range<Rng1> &&

  379.                         viewable_range<Rng2> && input_range<Rng2> &&

  380.                             indirect_relation<C, projected<iterator_t<Rng1>, P1>,

  381.                                               projected<iterator_t<Rng2>, P2>>)

  382.             {

  383.                 return {all(static_cast<Rng1 &&>(rng1)),

  384.                         all(static_cast<Rng2 &&>(rng2)),

  385.                         std::move(pred),

  386.                         std::move(proj1),

  387.                         std::move(proj2)};

  388.             }

  389.         };

  390. 

  391.         /// \relates set_intersection_fn

  392.         /// \ingroup group-views

  393.         RANGES_INLINE_VARIABLE(view<set_intersection_fn>, set_intersection)

  394.     } // namespace views

  395.     /// @}

  396. 

  397.     /// \cond

  398.     namespace detail

  399.     {

  400.         template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,

  401.                  typename P2>

  402.         struct set_union_cursor

  403.         {

  404.         private:

  405.             friend struct set_union_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;

  406.             using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;

  407.             using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;

  408.             using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;

  409.             pred_ref_ pred_;

  410.             proj1_ref_ proj1_;

  411.             proj2_ref_ proj2_;

  412. 

  413.             template<typename T>

  414.             using constify_if = meta::const_if_c<IsConst, T>;

  415. 

  416.             using R1 = constify_if<Rng1>;

  417.             using R2 = constify_if<Rng2>;

  418. 

  419.             iterator_t<R1> it1_;

  420.             sentinel_t<R1> end1_;

  421. 

  422.             iterator_t<R2> it2_;

  423.             sentinel_t<R2> end2_;

  424. 

  425.             enum class state_t

  426.             {

  427.                 FIRST,

  428.                 SECOND

  429.             } state;

  430. 

  431.             void satisfy()

  432.             {

  433.                 if(it1_ == end1_)

  434.                 {

  435.                     state = state_t::SECOND;

  436.                     return;

  437.                 }

  438. 

  439.                 if(it2_ == end2_)

  440.                 {

  441.                     state = state_t::FIRST;

  442.                     return;

  443.                 }

  444. 

  445.                 if(invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))

  446.                 {

  447.                     state = state_t::SECOND;

  448.                     return;

  449.                 }

  450. 

  451.                 if(!invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))

  452.                     ++it2_;

  453. 

  454.                 state = state_t::FIRST;

  455.             }

  456. 

  457.         public:

  458.             using value_type = common_type_t<range_value_t<R1>, range_value_t<R2>>;

  459.             using reference_type =

  460.                 common_reference_t<range_reference_t<R1>, range_reference_t<R2>>;

  461.             using rvalue_reference_type =

  462.                 common_reference_t<range_rvalue_reference_t<R1>,

  463.                                    range_rvalue_reference_t<R2>>;

  464.             using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,

  465.                                            single_pass_iterator_<iterator_t<R2>>>;

  466. 

  467.             set_union_cursor() = default;

  468.             set_union_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,

  469.                              iterator_t<R1> it1, sentinel_t<R1> end1, iterator_t<R2> it2,

  470.                              sentinel_t<R2> end2)

  471.               : pred_(std::move(pred))

  472.               , proj1_(std::move(proj1))

  473.               , proj2_(std::move(proj2))

  474.               , it1_(std::move(it1))

  475.               , end1_(std::move(end1))

  476.               , it2_(std::move(it2))

  477.               , end2_(std::move(end2))

  478.             {

  479.                 satisfy();

  480.             }

  481.             CPP_template(bool Other)( //

  482.                 requires IsConst && (!Other))

  483.                 set_union_cursor(set_union_cursor<Other, Rng1, Rng2, C, P1, P2> that)

  484.               : pred_(std::move(that.pred_))

  485.               , proj1_(std::move(that.proj1_))

  486.               , proj2_(std::move(that.proj2_))

  487.               , it1_(std::move(that.it1_))

  488.               , end1_(std::move(that.end1_))

  489.               , it2_(std::move(that.it2_))

  490.               , end2_(std::move(that.end2_))

  491.             {}

  492.             reference_type read() const noexcept(noexcept(*it1_) && noexcept(*it2_))

  493.             {

  494.                 if(state == state_t::SECOND)

  495.                     return *it2_;

  496.                 else

  497.                     return *it1_;

  498.             }

  499.             void next()

  500.             {

  501.                 if(state == state_t::FIRST)

  502.                     ++it1_;

  503.                 else

  504.                     ++it2_;

  505.                 satisfy();

  506.             }

  507.             CPP_member

  508.             auto equal(set_union_cursor const & that) const -> CPP_ret(bool)( //

  509.                 requires forward_range<Rng1> && forward_range<Rng2>)

  510.             {

  511.                 // does not support comparing iterators from different ranges

  512.                 return (it1_ == that.it1_) && (it2_ == that.it2_);

  513.             }

  514.             bool equal(default_sentinel_t) const

  515.             {

  516.                 return (it1_ == end1_) && (it2_ == end2_);

  517.             }

  518.             rvalue_reference_type move() const

  519.                 noexcept(noexcept(iter_move(it1_)) && noexcept(iter_move(it2_)))

  520.             {

  521.                 if(state == state_t::SECOND)

  522.                     return iter_move(it2_);

  523.                 else

  524.                     return iter_move(it1_);

  525.             }

  526.         };

  527. 

  528.         constexpr cardinality set_union_cardinality(cardinality c1, cardinality c2)

  529.         {

  530.             return (c1 == infinite) || (c2 == infinite)

  531.                        ? infinite

  532.                        : (c1 == unknown) || (c2 == unknown) ? unknown : finite;

  533.         }

  534. 

  535.     } // namespace detail

  536.     /// \endcond

  537. 

  538.     template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>

  539.     using set_union_view =

  540.         detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_union_cursor,

  541.                                    detail::set_union_cardinality(

  542.                                        range_cardinality<Rng1>::value,

  543.                                        range_cardinality<Rng2>::value)>;

  544. 

  545.     namespace views

  546.     {

  547.         struct set_union_fn

  548.         {

  549.         public:

  550.             template<typename Rng1, typename Rng2, typename C = less,

  551.                      typename P1 = identity, typename P2 = identity>

  552.             auto operator()(Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{},

  553.                             P2 proj2 = P2{}) const

  554.                 -> CPP_ret(set_union_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2>)( //

  555.                     requires viewable_range<Rng1> && input_range<Rng1> &&

  556.                         viewable_range<Rng2> && input_range<Rng2> && common_with<

  557.                             range_value_t<Rng1>, range_value_t<Rng2>> &&

  558.                             common_reference_with<range_reference_t<Rng1>,

  559.                                                   range_reference_t<Rng2>> &&

  560.                                 common_reference_with<range_rvalue_reference_t<Rng1>,

  561.                                                       range_rvalue_reference_t<Rng2>> &&

  562.                                     indirect_relation<C, projected<iterator_t<Rng1>, P1>,

  563.                                                       projected<iterator_t<Rng2>, P2>>)

  564.             {

  565.                 return {all(static_cast<Rng1 &&>(rng1)),

  566.                         all(static_cast<Rng2 &&>(rng2)),

  567.                         std::move(pred),

  568.                         std::move(proj1),

  569.                         std::move(proj2)};

  570.             }

  571.         };

  572. 

  573.         /// \relates set_union_fn

  574.         /// \ingroup group-views

  575.         RANGES_INLINE_VARIABLE(view<set_union_fn>, set_union)

  576.     } // namespace views

  577.     /// @}

  578. 

  579.     /// \cond

  580.     namespace detail

  581.     {

  582.         template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,

  583.                  typename P2>

  584.         struct set_symmetric_difference_cursor

  585.         {

  586.         private:

  587.             friend struct set_symmetric_difference_cursor<!IsConst, Rng1, Rng2, C, P1,

  588.                                                           P2>;

  589.             using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;

  590.             using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;

  591.             using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;

  592.             pred_ref_ pred_;

  593.             proj1_ref_ proj1_;

  594.             proj2_ref_ proj2_;

  595. 

  596.             template<typename T>

  597.             using constify_if = meta::const_if_c<IsConst, T>;

  598. 

  599.             using R1 = constify_if<Rng1>;

  600.             using R2 = constify_if<Rng2>;

  601. 

  602.             iterator_t<R1> it1_;

  603.             sentinel_t<R1> end1_;

  604. 

  605.             iterator_t<R2> it2_;

  606.             sentinel_t<R2> end2_;

  607. 

  608.             enum class state_t

  609.             {

  610.                 FIRST,

  611.                 SECOND,

  612.                 ONLY_FIRST,

  613.                 ONLY_SECOND

  614.             } state;

  615. 

  616.             void satisfy()

  617.             {

  618.                 while(it1_ != end1_)

  619.                 {

  620.                     if(it2_ == end2_)

  621.                     {

  622.                         state = state_t::ONLY_FIRST;

  623.                         return;

  624.                     }

  625. 

  626.                     if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))

  627.                     {

  628.                         state = state_t::FIRST;

  629.                         return;

  630.                     }

  631.                     else

  632.                     {

  633.                         if(invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))

  634.                         {

  635.                             state = state_t::SECOND;

  636.                             return;

  637.                         }

  638.                         else

  639.                         {

  640.                             ++it1_;

  641.                             ++it2_;

  642.                         }

  643.                     }

  644.                 }

  645.                 state = state_t::ONLY_SECOND;

  646.             }

  647. 

  648.         public:

  649.             using value_type = common_type_t<range_value_t<R1>, range_value_t<R2>>;

  650.             using reference_type =

  651.                 common_reference_t<range_reference_t<R1>, range_reference_t<R2>>;

  652.             using rvalue_reference_type =

  653.                 common_reference_t<range_rvalue_reference_t<R1>,

  654.                                    range_rvalue_reference_t<R2>>;

  655.             using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,

  656.                                            single_pass_iterator_<iterator_t<R2>>>;

  657. 

  658.             set_symmetric_difference_cursor() = default;

  659.             set_symmetric_difference_cursor(pred_ref_ pred, proj1_ref_ proj1,

  660.                                             proj2_ref_ proj2, iterator_t<R1> it1,

  661.                                             sentinel_t<R1> end1, iterator_t<R2> it2,

  662.                                             sentinel_t<R2> end2)

  663.               : pred_(std::move(pred))

  664.               , proj1_(std::move(proj1))

  665.               , proj2_(std::move(proj2))

  666.               , it1_(std::move(it1))

  667.               , end1_(std::move(end1))

  668.               , it2_(std::move(it2))

  669.               , end2_(std::move(end2))

  670.               , state()

  671.             {

  672.                 satisfy();

  673.             }

  674.             CPP_template(bool Other)(         //

  675.                 requires IsConst && (!Other)) //

  676.                 set_symmetric_difference_cursor(

  677.                     set_symmetric_difference_cursor<Other, Rng1, Rng2, C, P1, P2> that)

  678.               : pred_(std::move(that.pred_))

  679.               , proj1_(std::move(that.proj1_))

  680.               , proj2_(std::move(that.proj2_))

  681.               , it1_(std::move(that.it1_))

  682.               , end1_(std::move(that.end1_))

  683.               , it2_(std::move(that.it2_))

  684.               , end2_(std::move(that.end2_))

  685.               , state(that.state)

  686.             {}

  687.             reference_type read() const noexcept(noexcept(*it1_) && noexcept(*it2_))

  688.             {

  689.                 if(state == state_t::SECOND || state == state_t::ONLY_SECOND)

  690.                     return *it2_;

  691.                 else

  692.                     return *it1_;

  693.             }

  694.             void next()

  695.             {

  696.                 switch(state)

  697.                 {

  698.                 case state_t::FIRST:

  699.                     ++it1_;

  700.                     satisfy();

  701.                     break;

  702.                 case state_t::ONLY_FIRST:

  703.                     ++it1_;

  704.                     break;

  705.                 case state_t::SECOND:

  706.                     ++it2_;

  707.                     satisfy();

  708.                     break;

  709.                 case state_t::ONLY_SECOND:

  710.                     ++it2_;

  711.                     break;

  712.                 }

  713.             }

  714.             CPP_member

  715.             auto equal(set_symmetric_difference_cursor const & that) const

  716.                 -> CPP_ret(bool)( //

  717.                     requires forward_range<R1> && forward_range<R2>)

  718.             {

  719.                 // does not support comparing iterators from different ranges:

  720.                 return (it1_ == that.it1_) && (it2_ == that.it2_);

  721.             }

  722.             bool equal(default_sentinel_t) const

  723.             {

  724.                 return (it1_ == end1_) && (it2_ == end2_);

  725.             }

  726.             rvalue_reference_type move() const

  727.                 noexcept(noexcept(iter_move(it1_)) && noexcept(iter_move(it2_)))

  728.             {

  729.                 if(state == state_t::SECOND || state == state_t::ONLY_SECOND)

  730.                     return iter_move(it2_);

  731.                 else

  732.                     return iter_move(it1_);

  733.             }

  734.         };

  735. 

  736.         constexpr cardinality set_symmetric_difference_cardinality(cardinality c1,

  737.                                                                    cardinality c2)

  738.         {

  739.             return (c1 == unknown) || (c2 == unknown)

  740.                        ? unknown

  741.                        : (c1 == infinite) != (c2 == infinite)

  742.                              ? infinite

  743.                              : (c1 == infinite) && (c2 == infinite) ? unknown : finite;

  744.         }

  745. 

  746.     } // namespace detail

  747.     /// \endcond

  748. 

  749.     template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>

  750.     using set_symmetric_difference_view = detail::set_algorithm_view<

  751.         Rng1, Rng2, C, P1, P2, detail::set_symmetric_difference_cursor,

  752.         detail::set_symmetric_difference_cardinality(range_cardinality<Rng1>::value,

  753.                                                      range_cardinality<Rng2>::value)>;

  754. 

  755.     namespace views

  756.     {

  757.         struct set_symmetric_difference_fn

  758.         {

  759.         public:

  760.             template<typename Rng1, typename Rng2, typename C = less,

  761.                      typename P1 = identity, typename P2 = identity>

  762.             auto operator()(Rng1 && rng1, Rng2 && rng2, C pred = C{}, P1 proj1 = P1{},

  763.                             P2 proj2 = P2{}) const

  764.                 -> CPP_ret(set_symmetric_difference_view<all_t<Rng1>, all_t<Rng2>, C, P1,

  765.                                                          P2>)( //

  766.                     requires viewable_range<Rng1> && input_range<Rng1> &&

  767.                         viewable_range<Rng2> && input_range<Rng2> && common_with<

  768.                             range_value_t<Rng1>, range_value_t<Rng2>> &&

  769.                             common_reference_with<range_reference_t<Rng1>,

  770.                                                   range_reference_t<Rng2>> &&

  771.                                 common_reference_with<range_rvalue_reference_t<Rng1>,

  772.                                                       range_rvalue_reference_t<Rng2>> &&

  773.                                     indirect_relation<C, projected<iterator_t<Rng1>, P1>,

  774.                                                       projected<iterator_t<Rng2>, P2>>)

  775.             {

  776.                 return {all(static_cast<Rng1 &&>(rng1)),

  777.                         all(static_cast<Rng2 &&>(rng2)),

  778.                         std::move(pred),

  779.                         std::move(proj1),

  780.                         std::move(proj2)};

  781.             }

  782.         };

  783. 

  784.         /// \relates set_symmetric_difference_fn

  785.         /// \ingroup group-views

  786.         RANGES_INLINE_VARIABLE(view<set_symmetric_difference_fn>,

  787.                                set_symmetric_difference)

  788.     } // namespace views

  789.     /// @}

  790. } // namespace ranges

  791. 

  792. #endif