Function MapEqual

eval/internal/cel_value_equal.cc:93–143

// homogenous equality for comparing values.
template <typename EqualsProvider>
absl::optional<bool> MapEqual(const CelMap* t1, const CelMap* t2) {
  if (t1 == t2) {
    return true;
  }
  if (t1->size() != t2->size()) {
    return false;
  }

  google::protobuf::Arena arena;
  auto list_keys = t1->ListKeys(&arena);
  if (!list_keys.ok()) {
    return absl::nullopt;
  }
  const CelList* keys = *list_keys;
  for (int i = 0; i < keys->size(); i++) {
    CelValue key = (*keys).Get(&arena, i);
    CelValue v1 = (*t1).Get(&arena, key).value();
    absl::optional<CelValue> v2 = (*t2).Get(&arena, key);
    if (!v2.has_value()) {
      auto number = GetNumberFromCelValue(key);
      if (!number.has_value()) {
        return false;
      }
      if (!key.IsInt64() && number->LosslessConvertibleToInt()) {
        CelValue int_key = CelValue::CreateInt64(number->AsInt());
        absl::optional<bool> eq = EqualsProvider()(key, int_key);
        if (eq.has_value() && *eq) {
          v2 = (*t2).Get(&arena, int_key);
        }
      }
      if (!key.IsUint64() && !v2.has_value() &&
          number->LosslessConvertibleToUint()) {
        CelValue uint_key = CelValue::CreateUint64(number->AsUint());
        absl::optional<bool> eq = EqualsProvider()(key, uint_key);
        if (eq.has_value() && *eq) {
          v2 = (*t2).Get(&arena, uint_key);
        }
      }
    }
    if (!v2.has_value()) {
      return false;
    }
    absl::optional<bool> eq = EqualsProvider()(v1, *v2);
    if (!eq.has_value() || !*eq) {
      // Shortcircuit on value comparison errors and 'false' results.
      return eq;
    }
  }

  return true;
}

bool MessageEqual(const CelValue::MessageWrapper& m1,
                  const CelValue::MessageWrapper& m2) {