filter_view.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "../microfmt.hpp"
#include <cstddef>
#include <iterator>
#include <string_view>
#include <type_traits>
#include <utility>
 
namespace microfmt {
 
template <typename Range, typename Predicate> struct RELOCO_POINTER filtered_range_view {
  const Range &range;
  Predicate predicate;
  char open_delim{'['};
  char close_delim{']'};
  microfmt::string_view separator{", "};
};
 
template <typename T, typename Predicate> struct RELOCO_POINTER filtered_pointer_range_view {
  const T *data{nullptr};
  size_t count{0};
  Predicate predicate;
  char open_delim{'['};
  char close_delim{']'};
  microfmt::string_view separator{", "};
};
 
template <typename Range, typename Predicate>
[[nodiscard]] constexpr auto filter(const Range &rng, Predicate &&pred) noexcept {
  return filtered_range_view<Range, std::decay_t<Predicate>>{rng, std::forward<Predicate>(pred)};
}
 
template <typename Range, typename Predicate, std::enable_if_t<!std::is_lvalue_reference_v<Range>, int> = 0>
[[nodiscard]] constexpr auto filter(Range &&, Predicate &&) noexcept = delete;
 
template <typename T, typename Predicate>
[[nodiscard]] constexpr auto filter(const T *ptr, size_t count, Predicate &&pred) noexcept {
  return filtered_pointer_range_view<T, std::decay_t<Predicate>>{ptr, ptr == nullptr ? 0 : count,
                                                                 std::forward<Predicate>(pred)};
}
 
template <typename Range, typename Predicate> struct formatter<filtered_range_view<Range, Predicate>> {
  char open_c{'['};
  char close_c{']'};
  microfmt::string_view forwarded_spec{""};
 
  constexpr void parse(format_parse_context &ctx) noexcept {
    auto spec = ctx.spec();
    if (spec.empty())
      return;
 
    size_t i = 0;
    if (spec[0] == 'b' || spec[0] == 'B') {
      open_c = '[';
      close_c = ']';
      i = 1;
    } else if (spec[0] == 'c' || spec[0] == 'C') {
      open_c = '{';
      close_c = '}';
      i = 1;
    } else if (spec[0] == 'n' || spec[0] == 'N') {
      open_c = '\0';
      close_c = '\0';
      i = 1;
    }
    forwarded_spec = spec.substr(i);
  }
 
  void format(const filtered_range_view<Range, Predicate> &fv, const sink &out) const noexcept {
    if (open_c != '\0') {
      out.put(open_c);
    }
 
    using ElementReference = decltype(*std::begin(fv.range));
    using ElemType = typename std::remove_cv<typename std::remove_reference<ElementReference>::type>::type;
    detail::element_formatter<ElemType> elem_fmt;
    format_parse_context elem_ctx(forwarded_spec);
    elem_fmt.parse(elem_ctx);
 
    size_t matched_count = 0;
    for (const auto &item : fv.range) {
      if (fv.predicate(item)) {
        if (matched_count++ > 0) {
          out.write(fv.separator);
        }
        elem_fmt.format(item, out);
      }
    }
 
    if (close_c != '\0') {
      out.put(close_c);
    }
  }
};
 
template <typename T, typename Predicate> struct formatter<filtered_pointer_range_view<T, Predicate>> {
  char open_c{'['};
  char close_c{']'};
  microfmt::string_view forwarded_spec{""};
 
  constexpr void parse(format_parse_context &ctx) noexcept {
    auto spec = ctx.spec();
    if (spec.empty())
      return;
 
    size_t i = 0;
    if (spec[0] == 'b' || spec[0] == 'B') {
      open_c = '[';
      close_c = ']';
      i = 1;
    } else if (spec[0] == 'c' || spec[0] == 'C') {
      open_c = '{';
      close_c = '}';
      i = 1;
    } else if (spec[0] == 'n' || spec[0] == 'N') {
      open_c = '\0';
      close_c = '\0';
      i = 1;
    }
    forwarded_spec = spec.substr(i);
  }
 
  void format(const filtered_pointer_range_view<T, Predicate> &fv, const sink &out) const noexcept {
    if (open_c != '\0') {
      out.put(open_c);
    }
 
    detail::element_formatter<T> elem_fmt;
    format_parse_context elem_ctx(forwarded_spec);
    elem_fmt.parse(elem_ctx);
 
    size_t matched_count = 0;
    for (size_t i = 0; i < fv.count; ++i) {
      RELOCO_BEGIN_UNSAFE_BUFFER_USAGE;
      const T &item = fv.data[i];
      RELOCO_END_UNSAFE_BUFFER_USAGE;
 
      if (fv.predicate(item)) {
        if (matched_count++ > 0) {
          out.write(fv.separator);
        }
        elem_fmt.format(item, out);
      }
    }
 
    if (close_c != '\0') {
      out.put(close_c);
    }
  }
};
 
} // namespace microfmt