Function CaptureStringN

extensions/regex_functions.cc:106–150

Does a FullMatchN on the given string and regex and returns a map with pairs as follows: a. For a named group - b. For an unnamed group -

//   a. For a named group - <named_group_name, captured_string>
//   b. For an unnamed group - <group_index, captured_string>
absl::StatusOr<Value> CaptureStringN(
    int regex_max_program_size, const StringValue& target,
    const StringValue& regex,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) {
  std::string target_scratch;
  std::string regex_scratch;
  absl::string_view target_view = target.ToStringView(&target_scratch);
  absl::string_view regex_view = regex.ToStringView(&regex_scratch);
  RE2 re2(regex_view, cel::internal::MakeRE2Options());
  CEL_RETURN_IF_ERROR(cel::internal::CheckRE2(re2, regex_max_program_size))
      .With(ErrorValueReturn());
  const int capturing_groups_count = re2.NumberOfCapturingGroups();
  const auto& named_capturing_groups_map = re2.CapturingGroupNames();
  if (capturing_groups_count <= 0) {
    return ErrorValue(absl::InvalidArgumentError(
        "Capturing groups were not found in the given regex."));
  }
  std::vector<std::string> captured_strings(capturing_groups_count);
  std::vector<RE2::Arg> captured_string_addresses(capturing_groups_count);
  std::vector<RE2::Arg*> argv(capturing_groups_count);
  for (int j = 0; j < capturing_groups_count; j++) {
    captured_string_addresses[j] = &captured_strings[j];
    argv[j] = &captured_string_addresses[j];
  }
  bool result =
      RE2::FullMatchN(target_view, re2, argv.data(), capturing_groups_count);
  if (!result) {
    return ErrorValue(absl::InvalidArgumentError(
        "Unable to capture groups for the given regex"));
  }
  auto builder = cel::NewMapValueBuilder(arena);
  builder->Reserve(capturing_groups_count);
  for (int index = 1; index <= capturing_groups_count; index++) {
    auto it = named_capturing_groups_map.find(index);
    std::string name = it != named_capturing_groups_map.end()
                           ? it->second
                           : std::to_string(index);
    CEL_RETURN_IF_ERROR(builder->Put(
        StringValue::From(std::move(name), arena),
        StringValue::From(std::move(captured_strings[index - 1]), arena)));
  }
  return std::move(*builder).Build();
}

absl::Status RegisterRegexFunctions(FunctionRegistry& registry,
                                    int max_regex_program_size) {