.. _program_listing_file_include_beluga_actions_overlay.hpp:

Program Listing for File overlay.hpp
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_beluga_actions_overlay.hpp>` (``include/beluga/actions/overlay.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   // Copyright 2024 Ekumen, Inc.
   //
   // Licensed under the Apache License, Version 2.0 (the "License");
   // you may not use this file except in compliance with the License.
   // You may obtain a copy of the License at
   //
   //     http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
   // distributed under the License is distributed on an "AS IS" BASIS,
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   // See the License for the specific language governing permissions and
   // limitations under the License.
   
   #ifndef BELUGA_ACTIONS_OVERLAY_HPP
   #define BELUGA_ACTIONS_OVERLAY_HPP
   
   #include <algorithm>
   #include <execution>
   
   #include <range/v3/action/action.hpp>
   #include <range/v3/view/common.hpp>
   
   namespace beluga::actions {
   
   namespace detail {
   
   
   template <class MaskRange, class MaskValue, class ExecutionPolicy = std::execution::sequenced_policy>
   struct overlay_closure {
    public:
     static_assert(std::is_execution_policy_v<ExecutionPolicy>);
     static_assert(ranges::range<MaskRange>);
   
     constexpr overlay_closure(MaskRange mask_range, MaskValue mask_value)
         : policy_{std::execution::seq}, mask_range_{std::move(mask_range)}, mask_value_{std::move(mask_value)} {}
   
     constexpr explicit overlay_closure(ExecutionPolicy policy, MaskRange mask_range, MaskValue mask_value)
         : policy_{std::move(policy)}, mask_range_{std::move(mask_range)}, mask_value_{std::move(mask_value)} {}
   
     template <class Range>
     constexpr auto operator()(Range& range) const -> Range& {
       static_assert(ranges::range<Range>);
       auto common_range = range | ranges::views::common;
       const auto converted_mask_value = static_cast<ranges::range_value_t<Range>>(mask_value_);
   
       std::transform(
           policy_,                   //
           std::begin(common_range),  //
           std::end(common_range),    //
           std::begin(mask_range_),   //
           std::begin(common_range),  //
           [&converted_mask_value](const auto& base_value, bool flag) {
             return flag ? converted_mask_value : base_value;
           });
   
       return range;
     }
   
    private:
     ExecutionPolicy policy_{};
     MaskRange mask_range_{};
     MaskValue mask_value_{};
   };
   
   struct overlay_fn {
     template <
         class ExecutionPolicy,
         class Range,
         class MaskRange,
         class MaskValue,
         std::enable_if_t<std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>, int> = 0,
         std::enable_if_t<ranges::range<Range>, int> = 0,
         std::enable_if_t<ranges::range<MaskRange>, int> = 0>
     constexpr auto operator()(ExecutionPolicy&& policy, Range& range, MaskRange&& mask_range, MaskValue&& mask_value)
         const -> Range& {
       return overlay_closure{
           std::forward<ExecutionPolicy>(policy), std::forward<MaskRange>(mask_range),
           std::forward<MaskValue>(mask_value)}(range);
     }
   
     template <
         class Range,
         class MaskRange,
         class MaskValue,
         std::enable_if_t<ranges::range<Range>, int> = 0,
         std::enable_if_t<ranges::range<MaskRange>, int> = 0>
     constexpr auto operator()(Range& range, MaskRange&& mask_range, MaskValue&& mask_value) const -> Range& {
       return overlay_closure{std::forward<MaskRange>(mask_range), std::forward<MaskValue>(mask_value)}(range);
     }
   
     template <
         class ExecutionPolicy,
         class MaskRange,
         class MaskValue,
         std::enable_if_t<std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>, int> = 0,
         std::enable_if_t<ranges::range<MaskRange>, int> = 0>
     constexpr auto operator()(ExecutionPolicy&& policy, MaskRange&& mask_range, MaskValue&& mask_value) const {
       return ranges::actions::action_closure{overlay_closure{
           std::forward<ExecutionPolicy>(policy), std::forward<MaskRange>(mask_range),
           std::forward<MaskValue>(mask_value)}};
     }
   
     template <class MaskRange, class MaskValue, std::enable_if_t<ranges::range<MaskRange>, int> = 0>
     constexpr auto operator()(MaskRange&& mask_range, MaskValue&& mask_value) const {
       return ranges::actions::action_closure{
           overlay_closure{std::forward<MaskRange>(mask_range), std::forward<MaskValue>(mask_value)}};
     }
   };
   
   
   }  // namespace detail
   
   
   inline constexpr ranges::actions::action_closure<detail::overlay_fn> overlay;
   }  // namespace beluga::actions
   
   #endif