Function MapEqual

runtime/standard/equality_functions.cc:224–267

// homogenous equality for comparing values.
template <typename EqualsProvider>
absl::StatusOr<absl::optional<bool>> MapEqual(
    const MapValue& lhs, const MapValue& rhs,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) {
  if (&lhs == &rhs) {
    return true;
  }
  if (lhs.Size() != rhs.Size()) {
    return false;
  }

  CEL_ASSIGN_OR_RETURN(auto iter, lhs.NewIterator());

  while (iter->HasNext()) {
    CEL_ASSIGN_OR_RETURN(auto lhs_key,
                         iter->Next(descriptor_pool, message_factory, arena));

    absl::optional<Value> entry;
    CEL_ASSIGN_OR_RETURN(
        entry, rhs.Find(lhs_key, descriptor_pool, message_factory, arena));

    if (!entry && EqualsProvider::kIsHeterogeneous) {
      CEL_ASSIGN_OR_RETURN(
          entry, CheckAlternativeNumericType(lhs_key, rhs, descriptor_pool,
                                             message_factory, arena));
    }
    if (!entry) {
      return false;
    }

    CEL_ASSIGN_OR_RETURN(auto lhs_value, lhs.Get(lhs_key, descriptor_pool,
                                                 message_factory, arena));
    CEL_ASSIGN_OR_RETURN(absl::optional<bool> eq,
                         EqualsProvider()(lhs_value, *entry, descriptor_pool,
                                          message_factory, arena));

    if (!eq.has_value() || !*eq) {
      return eq;
    }
  }

  return true;
}

// Helper for wrapping ==/!= implementations.
// Name should point to a static constexpr string so the lambda capture is safe.