take_evenly.hpp

Go to the documentation of this file.

// Copyright 2023 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_VIEWS_TAKE_EVENLY_HPP
#define BELUGA_VIEWS_TAKE_EVENLY_HPP
 
#include <beluga/views/elements.hpp>
 
#include <range/v3/view/cache1.hpp>
#include <range/v3/view/enumerate.hpp>
#include <range/v3/view/filter.hpp>
 
namespace beluga::views {
 
namespace detail {
 
struct take_evenly_fn {  // NOLINT(readability-identifier-naming)
 
  template <class Range>
  constexpr auto operator()(Range&& range, std::size_t count) const {
    const std::size_t size = ranges::size(range);
 
    const auto filter_function = [size, count](const auto& pair) {
      if ((size == 0UL) || (count == 0UL)) {
        return false;
      }
 
      if (count > size) {
        return true;
      }
 
      const auto [index, _] = pair;
      if (count == 1UL) {
        return index == 0UL;
      }
 
      if ((index == 0UL) || (index == size - 1UL)) {
        return true;
      }
 
      const std::size_t m0 = (index - 1UL) * (count - 1UL) / (size - 1UL);
      const std::size_t m1 = index * (count - 1UL) / (size - 1UL);
      return m0 != m1;
    };
 
    // `cache1` ensures that views prior to `filter` in the pipeline are iterated exactly once.
    // This is needed because filter needs to dereference the input iterator twice.
    return ranges::views::enumerate(range) | ranges::views::cache1 | ranges::views::filter(filter_function) |
           beluga::views::elements<1>;
  }
 
 
  constexpr auto operator()(std::size_t count) const {
    return ranges::make_view_closure(ranges::bind_back(take_evenly_fn{}, count));
  }
};
 
}  // namespace detail
 
 
inline constexpr detail::take_evenly_fn take_evenly;  // NOLINT(readability-identifier-naming)
 
}  // namespace beluga::views
 
#endif