Add IsEmpty() function to reflection.

protobuf-github-bot · copybara-github · commit b64e490cf280 · 2025-09-17T09:02:50.000-07:00
This is faster than the current way of checking if a message is empty, which is to call ListFields() and check if the vector is empty.

PiperOrigin-RevId: 808175207
diff --git a/src/google/protobuf/extension_set.cc b/src/google/protobuf/extension_set.cc
@@ -219,6 +219,12 @@ void ExtensionSet::DeleteFlatMap(const ExtensionSet::KeyValue* flat,
 //                                 const DescriptorPool* pool,
 //                                 vector<const FieldDescriptor*>* output) const
 
+bool ExtensionSet::IsEmpty() const {
+  if (IsCompletelyEmpty()) return true;
+  return !AnyOfNoPrefetch(
+      [](const int number, const Extension& ext) { return ext.IsSet(); });
+}
+
 bool ExtensionSet::Has(int number) const {
   const Extension* ext = FindOrNull(number);
   if (ext == nullptr) return false;
diff --git a/src/google/protobuf/extension_set.h b/src/google/protobuf/extension_set.h
@@ -301,6 +301,11 @@ class PROTOBUF_EXPORT ExtensionSet {
   void AppendToList(const Descriptor* extendee, const DescriptorPool* pool,
                     std::vector<const FieldDescriptor*>* output) const;
 
+  // Whether there are any fields which are currently present. Note that this
+  // is different from IsCompletelyEmpty(), which returns false if the list has
+  // any capacity; and Size(), which also accounts for cleared fields.
+  bool IsEmpty() const;
+
   // =================================================================
   // Accessors
   //
@@ -747,6 +752,7 @@ class PROTOBUF_EXPORT ExtensionSet {
     void Clear();
     int GetSize() const;
     void Free();
+    bool IsSet() const { return is_repeated ? GetSize() > 0 : !is_cleared; }
     size_t SpaceUsedExcludingSelfLong() const;
     bool IsInitialized(const ExtensionSet* ext_set, const MessageLite* extendee,
                        int number, Arena* arena) const;
@@ -1004,6 +1010,19 @@ class PROTOBUF_EXPORT ExtensionSet {
     for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
   }
 
+  // Loops through [begin, end), and returns true as soon as some element
+  // satisfies predicate. Returns false if no element satisfies predicate.
+  template <typename Iterator, typename KeyValueFunctor>
+  static bool AnyOfNoPrefetch(Iterator begin, Iterator end,
+                              KeyValueFunctor predicate) {
+    for (Iterator it = begin; it != end; ++it) {
+      if (predicate(it->first, it->second)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   // Applies a functor to the <int, Extension&> pairs in sorted order.
   template <typename KeyValueFunctor>
   void ForEachNoPrefetch(KeyValueFunctor func) {
@@ -1026,6 +1045,18 @@ class PROTOBUF_EXPORT ExtensionSet {
     ForEachNoPrefetch(flat_begin(), flat_end(), std::move(func));
   }
 
+  // Loops through all <int, Extension&> pairs in sorted order, and returns true
+  // as soon as some element satisfies `predicate`. Returns false if no element
+  // satisfies predicate.
+  template <typename KeyValueFunctor>
+  bool AnyOfNoPrefetch(KeyValueFunctor predicate) const {
+    if (ABSL_PREDICT_FALSE(is_large())) {
+      return AnyOfNoPrefetch(map_.large->begin(), map_.large->end(),
+                             std::move(predicate));
+    }
+    return AnyOfNoPrefetch(flat_begin(), flat_end(), std::move(predicate));
+  }
+
   // Returns true if nothing is allocated in the ExtensionSet.
   bool IsCompletelyEmpty() const {
     return flat_size_ == 0 && flat_capacity_ == 0;
diff --git a/src/google/protobuf/extension_set_heavy.cc b/src/google/protobuf/extension_set_heavy.cc
@@ -55,14 +55,7 @@ void ExtensionSet::AppendToList(
     std::vector<const FieldDescriptor*>* output) const {
   ForEach(
       [extendee, pool, &output](int number, const Extension& ext) {
-        bool has = false;
-        if (ext.is_repeated) {
-          has = ext.GetSize() > 0;
-        } else {
-          has = !ext.is_cleared;
-        }
-
-        if (has) {
+        if (ext.IsSet()) {
           // TODO: Looking up each field by number is somewhat
           // unfortunate.
           //   Is there a better way?  The problem is that descriptors are
diff --git a/src/google/protobuf/generated_message_reflection.cc b/src/google/protobuf/generated_message_reflection.cc
@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <new>  // IWYU pragma: keep for operator delete
@@ -1761,13 +1762,23 @@ bool CreateUnknownEnumValues(const FieldDescriptor* field) {
 }  // namespace internal
 using internal::CreateUnknownEnumValues;
 
-void Reflection::ListFields(const Message& message,
-                            std::vector<const FieldDescriptor*>* output) const {
-  output->clear();
-
-  // Optimization:  The default instance never has any fields set.
-  if (schema_.IsDefaultInstance(message)) return;
 
+// Common functionality shared by IsEmpty and ListFields for iterating over
+// all set fields.
+//
+// If kForIsEmpty=true, returns 0 if the message is empty, and 1 otherwise.
+//
+// If kForIsEmpty=false, populates output with all filled fields. Return value
+// is the last field set, or 0 if the message is empty.
+template <bool kForIsEmpty, typename MaybeFieldDescriptorVec>
+inline int32_t Reflection::IsEmptyOrCollectSetFields(
+    const Message& message,
+    // Cached locally rather than a member variable for performance.
+    const Descriptor& descriptor,
+    [[maybe_unused]] MaybeFieldDescriptorVec output) const {
+  // Output should be null only if we are not computing the full output list.
+  static_assert(kForIsEmpty ==
+                std::is_same_v<MaybeFieldDescriptorVec, std::nullptr_t>);
   // Optimization: Avoid calling GetHasBits() and HasOneofField() many times
   // within the field loop.  We allow this violation of ReflectionSchema
   // encapsulation because this function takes a noticeable about of CPU
@@ -1776,17 +1787,33 @@ void Reflection::ListFields(const Message& message,
   const uint32_t* const has_bits =
       schema_.HasHasbits() ? GetHasBits(message) : nullptr;
   const uint32_t* const has_bits_indices = schema_.has_bit_indices_;
-  const Descriptor* const descriptor = descriptor_;
-  output->reserve(descriptor->field_count());
+  if constexpr (!kForIsEmpty) {
+    output->reserve(descriptor.field_count());
+  }
   // Fields in messages are usually added with the increasing tags.
   uint32_t last = 0;  // UINT32_MAX if out-of-order
-  auto append_to_output = [&last, &output](const FieldDescriptor* field) {
-    CheckInOrder(field, &last);
-    output->push_back(field);
-  };
+  // Stifle unused variable compilation error when kForIsEmpty is true.
+  [[maybe_unused]] const auto append_to_output =
+      [&last, output](const FieldDescriptor& field) {
+        if constexpr (!kForIsEmpty) {
+          CheckInOrder(&field, &last);
+          output->push_back(&field);
+        }
+      };
+  // Core functionality difference depending on the value of kForIsEmpty. If we
+  // encounter a set field, either return 1, or push it back into the vector.
+#define PROTO_REFLECTION_APPEND_OR_RETURN() \
+  do {                                      \
+    if constexpr (kForIsEmpty) {            \
+      return 1;                             \
+    } else {                                \
+      append_to_output(field);              \
+    }                                       \
+  } while (false)
+
   int i = -1;
   for (const FieldDescriptor& field :
-       absl::MakeSpan(descriptor->fields_, last_non_weak_field_index_ + 1)) {
+       absl::MakeSpan(descriptor.fields_, last_non_weak_field_index_ + 1)) {
     ++i;
     const OneofDescriptor* containing_oneof = field.containing_oneof();
     // If the hasbits for repeated fields experiment is disabled, we can
@@ -1795,7 +1822,7 @@ void Reflection::ListFields(const Message& message,
     if (!internal::EnableExperimentalHintHasBitsForRepeatedFields() &&
         field.is_repeated()) {
       if (FieldSize(message, &field) > 0) {
-        append_to_output(&field);
+        PROTO_REFLECTION_APPEND_OR_RETURN();
       }
     } else if (schema_.InRealOneof(&field)) {
       const uint32_t* const oneof_case_array =
@@ -1804,20 +1831,33 @@ void Reflection::ListFields(const Message& message,
       // Equivalent to: HasOneofField(message, field)
       if (static_cast<int64_t>(oneof_case_array[containing_oneof->index()]) ==
           field.number()) {
-        append_to_output(&field);
+        PROTO_REFLECTION_APPEND_OR_RETURN();
       }
     } else if (has_bits &&
                has_bits_indices[i] != static_cast<uint32_t>(kNoHasbit)) {
       // Equivalent to: HasFieldSingular(message, field)
       if (IsFieldPresentGivenHasbits(message, &field, has_bits,
                                      has_bits_indices[i])) {
-        append_to_output(&field);
+        PROTO_REFLECTION_APPEND_OR_RETURN();
       }
     } else if (HasFieldWithHasbits(message, &field)) {
-      // Fall back on proto3-style HasBit.
-      append_to_output(&field);
+      PROTO_REFLECTION_APPEND_OR_RETURN();
     }
   }
+#undef PROTO_REFLECTION_APPEND_OR_RETURN
+  // Last will be 0 if no fields were encountered. Otherwise it contains the
+  // last encountered field.
+  return last;
+}
+
+void Reflection::ListFields(const Message& message,
+                            std::vector<const FieldDescriptor*>* output) const {
+  output->clear();
+  // Optimization:  The default instance never has any fields set.
+  if (schema_.IsDefaultInstance(message)) return;
+  const Descriptor* const descriptor = descriptor_;
+  uint32_t last = IsEmptyOrCollectSetFields</*kForIsEmpty=*/false>(
+      message, *descriptor, output);
 
   // Descriptors of ExtensionSet are appended in their increasing tag
   // order and they are usually bigger than the field tags so if all fields are
@@ -1845,6 +1885,29 @@ void Reflection::ListFields(const Message& message,
   }
 }
 
+bool Reflection::IsEmptyIgnoringUnknownFieldsImpl(
+    const Message& message) const {
+  if (IsEmptyOrCollectSetFields</*kForIsEmpty=*/true>(message, *descriptor_,
+                                                      nullptr) != 0) {
+    return false;
+  }
+  return
+      !(schema_.HasExtensionSet() && !GetExtensionSet(message).IsEmpty());
+}
+
+bool Reflection::IsEmptyIgnoringUnknownFields(const Message& message) const {
+  // Optimization:  The default instance never has any fields set.
+  if (schema_.IsDefaultInstance(message)) return true;
+  return IsEmptyIgnoringUnknownFieldsImpl(message);
+}
+
+bool Reflection::IsEmpty(const Message& message) const {
+  // Optimization:  The default instance never has any fields set.
+  if (schema_.IsDefaultInstance(message)) return true;
+  return IsEmptyIgnoringUnknownFieldsImpl(message) &&
+         GetUnknownFields(message).empty();
+}
+
 // -------------------------------------------------------------------
 
 #undef DEFINE_PRIMITIVE_ACCESSORS
diff --git a/src/google/protobuf/generated_message_reflection_unittest.cc b/src/google/protobuf/generated_message_reflection_unittest.cc
diff --git a/src/google/protobuf/message.h b/src/google/protobuf/message.h
