EIC code displayed by LXR master/​include/​google/​protobuf/​extension_set.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-25 09:15:31

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 
 // Author: kenton@google.com (Kenton Varda)
 //  Based on original Protocol Buffers design by
 //  Sanjay Ghemawat, Jeff Dean, and others.
 //
 // This header is logically internal, but is made public because it is used
 // from protocol-compiler-generated code, which may reside in other components.
 
 #ifndef GOOGLE_PROTOBUF_EXTENSION_SET_H__
 #define GOOGLE_PROTOBUF_EXTENSION_SET_H__
 
 #include <algorithm>
 #include <atomic>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <initializer_list>
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <variant>
 #include <vector>
 
 #include "google/protobuf/stubs/common.h"
 #include "absl/base/casts.h"
 #include "absl/base/prefetch.h"
 #include "absl/container/btree_map.h"
 #include "absl/log/absl_check.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/generated_enum_util.h"
 #include "google/protobuf/generated_message_tctable_decl.h"
 #include "google/protobuf/internal_visibility.h"
 #include "google/protobuf/port.h"
 #include "google/protobuf/io/coded_stream.h"
 #include "google/protobuf/message_lite.h"
 #include "google/protobuf/parse_context.h"
 #include "google/protobuf/repeated_field.h"
 #include "google/protobuf/repeated_ptr_field.h"
 #include "google/protobuf/wire_format_lite.h"
 
 // clang-format off
 #include "google/protobuf/port_def.inc"  // Must be last
 // clang-format on
 
 #ifdef SWIG
 #error "You cannot SWIG proto headers"
 #endif
 
 
 namespace google {
 namespace protobuf {
 class Arena;
 class Descriptor;       // descriptor.h
 class FieldDescriptor;  // descriptor.h
 class DescriptorPool;   // descriptor.h
 class MessageLite;      // message_lite.h
 class Message;          // message.h
 class MessageFactory;   // message.h
 class Reflection;       // message.h
 class UnknownFieldSet;  // unknown_field_set.h
 class FeatureSet;
 namespace internal {
 struct DescriptorTable;
 class FieldSkipper;     // wire_format_lite.h
 class ReflectionVisit;  // message_reflection_util.h
 class WireFormat;
 struct DynamicExtensionInfoHelper;
 void InitializeLazyExtensionSet();
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google
 namespace pb {
 class CppFeatures;
 namespace internal {
 // Forward-declares the function for FeatureSet extensions to make it visible
 // to the internal feature helper. It should hold and return serialized
 // FeatureSetDefaults data.
 template <class T>
 inline ::absl::string_view GetFeatureSetDefaultsData();
 }  // namespace internal
 }  // namespace pb
 
 namespace google {
 namespace protobuf {
 namespace internal {
 
 class InternalMetadata;
 
 namespace v2 {
 class TableDrivenMessage;
 }  // namespace v2
 
 // Used to store values of type WireFormatLite::FieldType without having to
 // #include wire_format_lite.h.  Also, ensures that we use only one byte to
 // store these values, which is important to keep the layout of
 // ExtensionSet::Extension small.
 typedef uint8_t FieldType;
 
 // Version of the above which takes an argument.  This is needed to deal with
 // extensions that are not compiled in.
 typedef bool EnumValidityFuncWithArg(const void* arg, int number);
 
 enum class LazyAnnotation : int8_t {
   kUndefined = 0,
   kLazy = 1,
   kEager = 2,
 };
 
 // Information about a registered extension.
 struct ExtensionInfo {
   constexpr ExtensionInfo() : enum_validity_check() {}
   constexpr ExtensionInfo(const MessageLite* extendee, int param_number,
                           FieldType type_param, bool isrepeated, bool ispacked)
       : message(extendee),
         number(param_number),
         type(type_param),
         is_repeated(isrepeated),
         is_packed(ispacked),
         enum_validity_check() {}
   constexpr ExtensionInfo(const MessageLite* extendee, int param_number,
                           FieldType type_param, bool isrepeated, bool ispacked,
                           LazyEagerVerifyFnType verify_func,
                           LazyAnnotation islazy = LazyAnnotation::kUndefined)
       : message(extendee),
         number(param_number),
         type(type_param),
         is_repeated(isrepeated),
         is_packed(ispacked),
         is_lazy(islazy),
         enum_validity_check(),
         lazy_eager_verify_func(verify_func) {}
 
   const MessageLite* message = nullptr;
   int number = 0;
 
   FieldType type = 0;
   bool is_repeated = false;
   bool is_packed = false;
   LazyAnnotation is_lazy = LazyAnnotation::kUndefined;
 
   struct EnumValidityCheck {
     // TODO: Fully remove the function pointer approach.
     EnumValidityFuncWithArg* func;
     const void* arg;
 
     bool IsValid(int value) const {
       return func != nullptr ? func(arg, value)
                              : internal::ValidateEnum(
                                    value, static_cast<const uint32_t*>(arg));
     }
   };
 
   struct MessageInfo {
     const MessageLite* prototype = nullptr;
     // The TcParse table used for this object.
     // Never null. (except in platforms that don't constant initialize default
     // instances)
     const internal::TcParseTableBase* tc_table = nullptr;
 
     const ClassData* GetClassData() const {
 #ifdef PROTOBUF_CONSTINIT_DEFAULT_INSTANCES
       return tc_table->class_data;
 #else
       return google::protobuf::internal::GetClassData(*prototype);
 #endif
     }
   };
 
   union {
     EnumValidityCheck enum_validity_check;
     MessageInfo message_info;
   };
 
   // The descriptor for this extension, if one exists and is known.  May be
   // nullptr.  Must not be nullptr if the descriptor for the extension does not
   // live in the same pool as the descriptor for the containing type.
   const FieldDescriptor* descriptor = nullptr;
 
   // If this field is potentially lazy this function can be used as a cheap
   // verification of the raw bytes.
   // If nullptr then no verification is performed.
   LazyEagerVerifyFnType lazy_eager_verify_func = nullptr;
 };
 
 
 // An ExtensionFinder is an object which looks up extension definitions.  It
 // must implement this method:
 //
 // bool Find(int number, ExtensionInfo* output);
 
 // GeneratedExtensionFinder is an ExtensionFinder which finds extensions
 // defined in .proto files which have been compiled into the binary.
 class PROTOBUF_EXPORT GeneratedExtensionFinder {
  public:
   explicit GeneratedExtensionFinder(const MessageLite* extendee)
       : extendee_(extendee) {}
 
   // Returns true and fills in *output if found, otherwise returns false.
   bool Find(int number, ExtensionInfo* output);
 
  private:
   const MessageLite* extendee_;
 };
 
 // Note:  extension_set_heavy.cc defines DescriptorPoolExtensionFinder for
 // finding extensions from a DescriptorPool.
 
 // This is an internal helper class intended for use within the protocol buffer
 // library and generated classes.  Clients should not use it directly.  Instead,
 // use the generated accessors such as GetExtension() of the class being
 // extended.
 //
 // This class manages extensions for a protocol message object.  The
 // message's HasExtension(), GetExtension(), MutableExtension(), and
 // ClearExtension() methods are just thin wrappers around the embedded
 // ExtensionSet.  When parsing, if a tag number is encountered which is
 // inside one of the message type's extension ranges, the tag is passed
 // off to the ExtensionSet for parsing.  Etc.
 class PROTOBUF_EXPORT ExtensionSet {
  public:
   constexpr ExtensionSet() : ExtensionSet(nullptr) {}
   ExtensionSet(const ExtensionSet& rhs) = delete;
 
   // Arena enabled constructors: for internal use only.
   ExtensionSet(internal::InternalVisibility, Arena* arena)
       : ExtensionSet(arena) {}
 
   // TODO: make constructor private, and migrate `ArenaInitialized`
   // to `InternalVisibility` overloaded constructor(s).
   explicit constexpr ExtensionSet(Arena* arena);
   ExtensionSet(ArenaInitialized, Arena* arena) : ExtensionSet(arena) {}
 
   ExtensionSet& operator=(const ExtensionSet&) = delete;
   ~ExtensionSet();
 
   // These are called at startup by protocol-compiler-generated code to
   // register known extensions.  The registrations are used by ParseField()
   // to look up extensions for parsed field numbers.  Note that dynamic parsing
   // does not use ParseField(); only protocol-compiler-generated parsing
   // methods do.
   static void RegisterExtension(const MessageLite* extendee, int number,
                                 FieldType type, bool is_repeated,
                                 bool is_packed);
   static void RegisterEnumExtension(const MessageLite* extendee, int number,
                                     FieldType type, bool is_repeated,
                                     bool is_packed,
                                     const uint32_t* validation_data);
   static void RegisterMessageExtension(const MessageLite* extendee, int number,
                                        FieldType type, bool is_repeated,
                                        bool is_packed,
                                        const MessageLite* prototype,
                                        LazyEagerVerifyFnType verify_func,
                                        LazyAnnotation is_lazy);
 
   // In weak descriptor mode we register extensions in two phases.
   // This function determines if it is the right time to register a particular
   // extension.
   // During "preregistration" we only register extensions that have all their
   // types linked in.
   struct WeakPrototypeRef {
     const internal::DescriptorTable* table;
     int index;
   };
   static bool ShouldRegisterAtThisTime(
       std::initializer_list<WeakPrototypeRef> messages,
       bool is_preregistration);
 
   // =================================================================
 
   // Add all fields which are currently present to the given vector.  This
   // is useful to implement Reflection::ListFields(). Descriptors are appended
   // in increasing tag order.
   void AppendToList(const Descriptor* extendee, const DescriptorPool* pool,
                     std::vector<const FieldDescriptor*>* output) const;
 
   // =================================================================
   // Accessors
   //
   // Generated message classes include type-safe templated wrappers around
   // these methods.  Generally you should use those rather than call these
   // directly, unless you are doing low-level memory management.
   //
   // When calling any of these accessors, the extension number requested
   // MUST exist in the DescriptorPool provided to the constructor.  Otherwise,
   // the method will fail an assert.  Normally, though, you would not call
   // these directly; you would either call the generated accessors of your
   // message class (e.g. GetExtension()) or you would call the accessors
   // of the reflection interface.  In both cases, it is impossible to
   // trigger this assert failure:  the generated accessors only accept
   // linked-in extension types as parameters, while the Reflection interface
   // requires you to provide the FieldDescriptor describing the extension.
   //
   // When calling any of these accessors, a protocol-compiler-generated
   // implementation of the extension corresponding to the number MUST
   // be linked in, and the FieldDescriptor used to refer to it MUST be
   // the one generated by that linked-in code.  Otherwise, the method will
   // die on an assert failure.  The message objects returned by the message
   // accessors are guaranteed to be of the correct linked-in type.
   //
   // These methods pretty much match Reflection except that:
   // - They're not virtual.
   // - They identify fields by number rather than FieldDescriptors.
   // - They identify enum values using integers rather than descriptors.
   // - Strings provide Mutable() in addition to Set() accessors.
 
   bool Has(int number) const;
   int ExtensionSize(int number) const;  // Size of a repeated extension.
   int NumExtensions() const;            // The number of extensions
   FieldType ExtensionType(int number) const;
   void ClearExtension(int number);
 
   // singular fields -------------------------------------------------
 
   template <typename T>
   const T& Get(int number,
                const internal::type_identity_t<T>& default_value) const {
     const Extension* extension = FindOrNull(number);
     if (extension == nullptr || extension->is_cleared) {
       return default_value;
     } else {
       return extension->Get<T>();
     }
   }
 
   template <typename T, typename U>
   void Set(int number, FieldType type, U&& value,
            const FieldDescriptor* descriptor) {
     if constexpr (Extension::kUsesPointer<T>) {
       Extension& extension =
           FindOrCreate(number, type, false, false, descriptor, CreateImpl<T>);
       *extension.Mutable<T>() = std::forward<U>(value);
     } else {
       FindOrCreate(number, type, false, false, descriptor, nullptr)
           .Mutable<T>() = std::forward<U>(value);
     }
   }
 
   const MessageLite& GetMessage(int number,
                                 const MessageLite& default_value) const;
   const MessageLite& GetMessage(int number, const Descriptor* message_type,
                                 MessageFactory* factory) const;
 
   // |descriptor| may be nullptr so long as it is known that the descriptor for
   // the extension lives in the same pool as the descriptor for the containing
   // type.
 #define desc const FieldDescriptor* descriptor  // avoid line wrapping
   std::string* MutableString(int number, FieldType type, desc);
   MessageLite* MutableMessage(int number, FieldType type,
                               const MessageLite& prototype, desc);
   MessageLite* MutableMessage(const FieldDescriptor* descriptor,
                               MessageFactory* factory);
   // Adds the given message to the ExtensionSet, taking ownership of the
   // message object. Existing message with the same number will be deleted.
   // If "message" is nullptr, this is equivalent to "ClearExtension(number)".
   void SetAllocatedMessage(int number, FieldType type,
                            const FieldDescriptor* descriptor,
                            MessageLite* message);
   void UnsafeArenaSetAllocatedMessage(int number, FieldType type,
                                       const FieldDescriptor* descriptor,
                                       MessageLite* message);
   [[nodiscard]] MessageLite* ReleaseMessage(int number,
                                             const MessageLite& prototype);
   MessageLite* UnsafeArenaReleaseMessage(int number,
                                          const MessageLite& prototype);
 
   [[nodiscard]] MessageLite* ReleaseMessage(const FieldDescriptor* descriptor,
                                             MessageFactory* factory);
   MessageLite* UnsafeArenaReleaseMessage(const FieldDescriptor* descriptor,
                                          MessageFactory* factory);
 #undef desc
   Arena* GetArena() const { return arena_; }
 
   // repeated fields -------------------------------------------------
 
   // Fetches a RepeatedField extension by number; returns |default_value|
   // if no such extension exists. User should not touch this directly; it is
   // used by the GetRepeatedExtension() method.
   const void* GetRawRepeatedField(int number, const void* default_value) const;
   // Fetches a mutable version of a RepeatedField extension by number,
   // instantiating one if none exists. Similar to above, user should not use
   // this directly; it underlies MutableRepeatedExtension().
   void* MutableRawRepeatedField(int number, FieldType field_type, bool packed,
                                 const FieldDescriptor* desc);
 
   // This is an overload of MutableRawRepeatedField to maintain compatibility
   // with old code using a previous API. This version of
   // MutableRawRepeatedField() will ABSL_CHECK-fail on a missing extension.
   // (E.g.: borg/clients/internal/proto1/proto2_reflection.cc.)
   void* MutableRawRepeatedField(int number);
 
   template <typename T>
   const T& GetRepeated(int number, int index) const {
     const Extension* extension = FindOrNull(number);
     ABSL_CHECK(extension != nullptr) << "Index out-of-bounds (field is empty).";
     return extension->Get<RepFor<T>>().Get(index);
   }
 
   template <typename T, typename U>
   void SetRepeated(int number, int index, U&& value) {
     Extension* extension = FindOrNull(number);
     ABSL_CHECK(extension != nullptr) << "Index out-of-bounds (field is empty).";
     (*extension->Mutable<RepFor<T>>())[index] = std::forward<U>(value);
   }
 
   template <typename T>
   auto& Add(int number, FieldType type, const FieldDescriptor* descriptor) {
     static_assert(std::is_class_v<T>);
     Extension& ext = FindOrCreate(number, type, true, false, descriptor,
                                   &CreateImpl<RepFor<T>>);
     return *ext.Mutable<RepFor<T>>()->Add();
   }
 
   template <typename T>
   void Add(int number, FieldType type, bool packed, T value,
            const FieldDescriptor* descriptor) {
     static_assert(std::is_arithmetic_v<T>,
                   "Only arithmetic types take `packed`");
     Extension& ext = FindOrCreate(number, type, true, packed, descriptor,
                                   &CreateImpl<RepFor<T>>);
     ext.Mutable<RepFor<T>>()->Add(value);
   }
 
   const MessageLite& GetRepeatedMessage(int number, int index) const;
   std::string* MutableRepeatedString(int number, int index);
   MessageLite* MutableRepeatedMessage(int number, int index);
 
 #define desc const FieldDescriptor* descriptor  // avoid line wrapping
   std::string* AddString(int number, FieldType type, desc);
   MessageLite* AddMessage(int number, FieldType type,
                           const ClassData* class_data, desc);
   MessageLite* AddMessage(const FieldDescriptor* descriptor,
                           MessageFactory* factory);
   void AddAllocatedMessage(const FieldDescriptor* descriptor,
                            MessageLite* new_entry);
   void UnsafeArenaAddAllocatedMessage(const FieldDescriptor* descriptor,
                                       MessageLite* new_entry);
 #undef desc
 
   void RemoveLast(int number);
   [[nodiscard]] MessageLite* ReleaseLast(int number);
   MessageLite* UnsafeArenaReleaseLast(int number);
   void SwapElements(int number, int index1, int index2);
 
   // =================================================================
   // convenience methods for implementing methods of Message
   //
   // These could all be implemented in terms of the other methods of this
   // class, but providing them here helps keep the generated code size down.
 
   void Clear();
   void MergeFrom(const MessageLite* extendee, const ExtensionSet& other);
   void Swap(const MessageLite* extendee, ExtensionSet* other);
   void InternalSwap(ExtensionSet* other);
   void SwapExtension(const MessageLite* extendee, ExtensionSet* other,
                      int number);
   void UnsafeShallowSwapExtension(ExtensionSet* other, int number);
   bool IsInitialized(const MessageLite* extendee) const;
 
   // Lite parser
   const char* ParseField(uint64_t tag, const char* ptr,
                          const MessageLite* extendee,
                          internal::InternalMetadata* metadata,
                          internal::ParseContext* ctx);
   // Full parser
   const char* ParseField(uint64_t tag, const char* ptr, const Message* extendee,
                          internal::InternalMetadata* metadata,
                          internal::ParseContext* ctx);
   template <typename Msg>
   const char* ParseMessageSet(const char* ptr, const Msg* extendee,
                               InternalMetadata* metadata,
                               internal::ParseContext* ctx) {
     while (!ctx->Done(&ptr)) {
       uint32_t tag;
       ptr = ReadTag(ptr, &tag);
       GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
       if (tag == WireFormatLite::kMessageSetItemStartTag) {
         ptr = ctx->ParseGroupInlined(ptr, tag, [&](const char* ptr) {
           return ParseMessageSetItem(ptr, extendee, metadata, ctx);
         });
         GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
       } else {
         if (tag == 0 || (tag & 7) == 4) {
           ctx->SetLastTag(tag);
           return ptr;
         }
         ptr = ParseField(tag, ptr, extendee, metadata, ctx);
         GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
       }
     }
     return ptr;
   }
 
   // Write all extension fields with field numbers in the range
   //   [start_field_number, end_field_number)
   // to the output stream, using the cached sizes computed when ByteSize() was
   // last called.  Note that the range bounds are inclusive-exclusive.
   void SerializeWithCachedSizes(const MessageLite* extendee,
                                 int start_field_number, int end_field_number,
                                 io::CodedOutputStream* output) const {
     output->SetCur(_InternalSerialize(extendee, start_field_number,
                                       end_field_number, output->Cur(),
                                       output->EpsCopy()));
   }
 
   // Same as SerializeWithCachedSizes, but without any bounds checking.
   // The caller must ensure that target has sufficient capacity for the
   // serialized extensions.
   //
   // Returns a pointer past the last written byte.
   uint8_t* _InternalSerialize(const MessageLite* extendee,
                               int start_field_number, int end_field_number,
                               uint8_t* target,
                               io::EpsCopyOutputStream* stream) const {
     if (flat_size_ == 0) {
       assert(!is_large());
       return target;
     }
     return _InternalSerializeImpl(extendee, start_field_number,
                                   end_field_number, target, stream);
   }
 
   // Same as _InternalSerialize, but do not verify the range of field numbers.
   uint8_t* _InternalSerializeAll(const MessageLite* extendee, uint8_t* target,
                                  io::EpsCopyOutputStream* stream) const {
     if (flat_size_ == 0) {
       assert(!is_large());
       return target;
     }
     return _InternalSerializeAllImpl(extendee, target, stream);
   }
 
   // Like above but serializes in MessageSet format.
   void SerializeMessageSetWithCachedSizes(const MessageLite* extendee,
                                           io::CodedOutputStream* output) const {
     output->SetCur(InternalSerializeMessageSetWithCachedSizesToArray(
         extendee, output->Cur(), output->EpsCopy()));
   }
   uint8_t* InternalSerializeMessageSetWithCachedSizesToArray(
       const MessageLite* extendee, uint8_t* target,
       io::EpsCopyOutputStream* stream) const;
 
   // For backward-compatibility, versions of two of the above methods that
   // serialize deterministically iff SetDefaultSerializationDeterministic()
   // has been called.
   uint8_t* SerializeWithCachedSizesToArray(int start_field_number,
                                            int end_field_number,
                                            uint8_t* target) const;
   uint8_t* SerializeMessageSetWithCachedSizesToArray(
       const MessageLite* extendee, uint8_t* target) const;
 
   // Returns the total serialized size of all the extensions.
   size_t ByteSize() const;
 
   // Like ByteSize() but uses MessageSet format.
   size_t MessageSetByteSize() const;
 
   // Returns (an estimate of) the total number of bytes used for storing the
   // extensions in memory, excluding sizeof(*this).  If the ExtensionSet is
   // for a lite message (and thus possibly contains lite messages), the results
   // are undefined (might work, might crash, might corrupt data, might not even
   // be linked in).  It's up to the protocol compiler to avoid calling this on
   // such ExtensionSets (easy enough since lite messages don't implement
   // SpaceUsed()).
   size_t SpaceUsedExcludingSelfLong() const;
 
   // This method just calls SpaceUsedExcludingSelfLong() but it can not be
   // inlined because the definition of SpaceUsedExcludingSelfLong() is not
   // included in lite runtime and when an inline method refers to it MSVC
   // will complain about unresolved symbols when building the lite runtime
   // as .dll.
   int SpaceUsedExcludingSelf() const;
 
   static constexpr size_t InternalGetArenaOffset(internal::InternalVisibility) {
     return PROTOBUF_FIELD_OFFSET(ExtensionSet, arena_);
   }
 
  private:
   template <typename Type>
   friend class PrimitiveTypeTraits;
 
   template <typename Type>
   friend class RepeatedPrimitiveTypeTraits;
 
   template <typename Type>
   friend class EnumTypeTraits;
 
   template <typename Type>
   friend class RepeatedEnumTypeTraits;
 
   friend class google::protobuf::Reflection;
   friend class google::protobuf::internal::ReflectionVisit;
   friend struct google::protobuf::internal::DynamicExtensionInfoHelper;
   friend class google::protobuf::internal::WireFormat;
   friend class google::protobuf::internal::v2::TableDrivenMessage;
 
   friend void internal::InitializeLazyExtensionSet();
 
   // The repeated field type for T.
   template <typename T>
   using RepFor = std::conditional_t<std::is_arithmetic_v<T>,
                                     RepeatedField<std::decay_t<T>>,
                                     RepeatedPtrField<std::decay_t<T>>>;
 
   static bool FieldTypeIsPointer(FieldType type);
 
   size_t GetMessageByteSizeLong(int number) const;
   uint8_t* InternalSerializeMessage(int number, const MessageLite* prototype,
                                     uint8_t* target,
                                     io::EpsCopyOutputStream* stream) const;
 
   // Implementation of _InternalSerialize for non-empty map_.
   uint8_t* _InternalSerializeImpl(const MessageLite* extendee,
                                   int start_field_number, int end_field_number,
                                   uint8_t* target,
                                   io::EpsCopyOutputStream* stream) const;
   // Implementation of _InternalSerializeAll for non-empty map_.
   uint8_t* _InternalSerializeAllImpl(const MessageLite* extendee,
                                      uint8_t* target,
                                      io::EpsCopyOutputStream* stream) const;
   // Implementation of _InternalSerialize for large map_.
   // Extracted as a separate method to avoid inlining and to reuse in
   // _InternalSerializeAllImpl.
   uint8_t* _InternalSerializeImplLarge(const MessageLite* extendee,
                                        int start_field_number,
                                        int end_field_number, uint8_t* target,
                                        io::EpsCopyOutputStream* stream) const;
   // Interface of a lazily parsed singular message extension.
   class PROTOBUF_EXPORT LazyMessageExtension {
    public:
     LazyMessageExtension() = default;
     LazyMessageExtension(const LazyMessageExtension&) = delete;
     LazyMessageExtension& operator=(const LazyMessageExtension&) = delete;
     virtual ~LazyMessageExtension() = default;
 
     virtual LazyMessageExtension* Clone(Arena* arena,
                                         const LazyMessageExtension& other,
                                         Arena* other_arena) const = 0;
     virtual const MessageLite& GetMessage(const MessageLite& prototype,
                                           Arena* arena) const = 0;
     virtual const MessageLite& GetMessageIgnoreUnparsed(
         const MessageLite& prototype, Arena* arena) const = 0;
     virtual MessageLite* MutableMessage(const MessageLite& prototype,
                                         Arena* arena) = 0;
     virtual void SetAllocatedMessage(MessageLite* message, Arena* arena) = 0;
     virtual void UnsafeArenaSetAllocatedMessage(MessageLite* message,
                                                 Arena* arena) = 0;
     [[nodiscard]] virtual MessageLite* ReleaseMessage(
         const MessageLite& prototype, Arena* arena) = 0;
     virtual MessageLite* UnsafeArenaReleaseMessage(const MessageLite& prototype,
                                                    Arena* arena) = 0;
 
     virtual bool IsInitialized(const MessageLite* prototype,
                                Arena* arena) const = 0;
     virtual bool IsEagerSerializeSafe(const MessageLite* prototype,
                                       Arena* arena) const = 0;
 
     [[deprecated("Please use ByteSizeLong() instead")]] virtual int ByteSize()
         const {
       return internal::ToIntSize(ByteSizeLong());
     }
     virtual size_t ByteSizeLong() const = 0;
     virtual size_t SpaceUsedLong() const = 0;
 
     virtual std::variant<size_t, const MessageLite*> UnparsedSizeOrMessage()
         const = 0;
 
     virtual void MergeFrom(const MessageLite* prototype,
                            const LazyMessageExtension& other, Arena* arena,
                            Arena* other_arena) = 0;
     virtual void MergeFromMessage(const MessageLite& msg, Arena* arena) = 0;
     virtual void Clear() = 0;
 
     virtual const char* _InternalParse(const MessageLite& prototype,
                                        Arena* arena, const char* ptr,
                                        ParseContext* ctx) = 0;
     virtual uint8_t* WriteMessageToArray(
         const MessageLite* prototype, int number, uint8_t* target,
         io::EpsCopyOutputStream* stream) const = 0;
 
 
    private:
     virtual void UnusedKeyMethod();  // Dummy key method to avoid weak vtable.
   };
   // Give access to function defined below to see LazyMessageExtension.
   static LazyMessageExtension* MaybeCreateLazyExtensionImpl(Arena* arena);
   static LazyMessageExtension* MaybeCreateLazyExtension(Arena* arena) {
     auto* f = maybe_create_lazy_extension_.load(std::memory_order_relaxed);
     return f != nullptr ? f(arena) : nullptr;
   }
   static std::atomic<LazyMessageExtension* (*)(Arena* arena)>
       maybe_create_lazy_extension_;
 
   // We can't directly use std::atomic for Extension::cached_size because
   // Extension needs to be trivially copyable.
   class TrivialAtomicInt {
    public:
     int operator()() const {
       return reinterpret_cast<const AtomicT*>(int_)->load(
           std::memory_order_relaxed);
     }
     void set(int v) {
       reinterpret_cast<AtomicT*>(int_)->store(v, std::memory_order_relaxed);
     }
 
    private:
     using AtomicT = std::atomic<int>;
     alignas(AtomicT) char int_[sizeof(AtomicT)];
   };
 
   struct Extension {
     // Some helper methods for operations on a single Extension.
     uint8_t* InternalSerializeFieldWithCachedSizesToArray(
         const MessageLite* extendee, const ExtensionSet* extension_set,
         int number, uint8_t* target, io::EpsCopyOutputStream* stream) const;
     uint8_t* InternalSerializeMessageSetItemWithCachedSizesToArray(
         const MessageLite* extendee, const ExtensionSet* extension_set,
         int number, uint8_t* target, io::EpsCopyOutputStream* stream) const;
     size_t ByteSize(int number) const;
     size_t MessageSetItemByteSize(int number) const;
     void Clear();
     int GetSize() const;
     void Free();
     size_t SpaceUsedExcludingSelfLong() const;
     bool IsInitialized(const ExtensionSet* ext_set, const MessageLite* extendee,
                        int number, Arena* arena) const;
     const void* PrefetchPtr() const {
       ABSL_DCHECK_EQ(is_pointer, is_repeated || FieldTypeIsPointer(type));
       // We don't want to prefetch invalid/null pointers so if there isn't a
       // pointer to prefetch, then return `this`.
       return is_pointer ? raw_ptr() : this;
     }
 
     // The order of these fields packs Extension into 24 bytes when using 8
     // byte alignment. Consider this when adding or removing fields here.
 
     // We need a separate named union for pointer values to allow for
     // prefetching the pointer without undefined behavior.
     union Pointer {
       std::string* string_value;
       MessageLite* message_value;
       LazyMessageExtension* lazymessage_value;
 
       RepeatedField<int32_t>* repeated_int32_t_value;
       RepeatedField<int64_t>* repeated_int64_t_value;
       RepeatedField<uint32_t>* repeated_uint32_t_value;
       RepeatedField<uint64_t>* repeated_uint64_t_value;
       RepeatedField<float>* repeated_float_value;
       RepeatedField<double>* repeated_double_value;
       RepeatedField<bool>* repeated_bool_value;
       RepeatedPtrField<std::string>* repeated_string_value;
       RepeatedPtrField<MessageLite>* repeated_message_value;
     };
 
     union {
       int32_t int32_t_value;
       int64_t int64_t_value;
       uint32_t uint32_t_value;
       uint64_t uint64_t_value;
       float float_value;
       double double_value;
       bool bool_value;
       Pointer ptr;
     };
 
     template <typename T>
     static inline constexpr auto kUnionMember = std::get<T Extension::*>(
         std::tuple{&Extension::int32_t_value, &Extension::int64_t_value,
                    &Extension::uint32_t_value, &Extension::uint64_t_value,
                    &Extension::float_value, &Extension::double_value,
                    &Extension::bool_value});
 
     template <typename T>
     static inline constexpr auto kPtrUnionMember =
         std::get<T Pointer::*>(std::tuple{
             // we omit message fields because those have custom behavior.
             &Pointer::string_value, &Pointer::repeated_int32_t_value,
             &Pointer::repeated_int64_t_value, &Pointer::repeated_uint32_t_value,
             &Pointer::repeated_uint64_t_value, &Pointer::repeated_float_value,
             &Pointer::repeated_double_value, &Pointer::repeated_bool_value,
             &Pointer::repeated_string_value, &Pointer::repeated_message_value});
 
     void* raw_ptr() const { return absl::bit_cast<void*>(ptr); }
 
     template <typename T>
     static inline constexpr bool kUsesPointer = !std::is_arithmetic_v<T>;
 
     template <typename T>
     void VerifyType() const {
       ABSL_DCHECK_EQ(is_repeated || FieldTypeIsPointer(type), kUsesPointer<T>);
       constexpr auto expected_cpp_type = WireFormatLite::CppTypeFor<T>();
       ABSL_DCHECK_EQ(
           +expected_cpp_type,
           +(type == WireFormatLite::TYPE_ENUM
                 ? WireFormatLite::CPPTYPE_INT32
                 : WireFormatLite::FieldTypeToCppType(
                       static_cast<WireFormatLite::FieldType>(type))));
     }
 
     // Returns a reference to the union member for T.
     // For pointer-stored types, follow the pointer.
     template <typename T>
     const T& Get() const {
       VerifyType<T>();
       if constexpr (kUsesPointer<T>) {
         return *(ptr.*kPtrUnionMember<T*>);
       } else {
         return this->*kUnionMember<T>;
       }
     }
 
     // Returns a reference to the union member for T.
     // For pointer-stored types, return a reference to the pointer.
     template <typename T>
     auto& Mutable() {
       VerifyType<T>();
       if constexpr (kUsesPointer<T>) {
         return ptr.*kPtrUnionMember<T*>;
       } else {
         return this->*kUnionMember<T>;
       }
     }
 
     FieldType type;
     bool is_repeated;
 
     // Whether the extension is a pointer. This is used for prefetching.
     bool is_pointer : 1;
 
     // For singular types, indicates if the extension is "cleared".  This
     // happens when an extension is set and then later cleared by the caller.
     // We want to keep the Extension object around for reuse, so instead of
     // removing it from the map, we just set is_cleared = true.
     //
     // This is always set to false for repeated types.
     // The size of the RepeatedField simply becomes zero when cleared.
     bool is_cleared : 1;
 
     // For singular message types, indicates whether lazy parsing is enabled
     // for this extension. This field is only valid when type == TYPE_MESSAGE
     // and !is_repeated because we only support lazy parsing for singular
     // message types currently. If is_lazy = true, the extension is stored in
     // lazymessage_value. Otherwise, the extension will be message_value.
     bool is_lazy : 1;
 
     // For repeated types, this indicates if the [packed=true] option is set.
     bool is_packed;
 
     // For packed fields, the size of the packed data is recorded here when
     // ByteSize() is called then used during serialization.
     mutable TrivialAtomicInt cached_size;
 
     // The descriptor for this extension, if one exists and is known.  May be
     // nullptr.  Must not be nullptr if the descriptor for the extension does
     // not live in the same pool as the descriptor for the containing type.
     const FieldDescriptor* descriptor;
   };
 
   // The Extension struct is small enough to be passed by value so we use it
   // directly as the value type in mappings rather than use pointers. We use
   // sorted maps rather than hash-maps because we expect most ExtensionSets will
   // only contain a small number of extensions, and we want AppendToList and
   // deterministic serialization to order fields by field number. In flat mode,
   // the number of elements is small enough that linear search is faster than
   // binary search.
 
   struct KeyValue {
     int first;
     Extension second;
   };
 
   using LargeMap = absl::btree_map<int, Extension>;
 
   // Wrapper API that switches between flat-map and LargeMap.
 
   // Finds a key (if present) in the ExtensionSet.
   const Extension* FindOrNull(int key) const;
   Extension* FindOrNull(int key);
 
   // Helper-functions that only inspect the LargeMap.
   const Extension* FindOrNullInLargeMap(int key) const;
   Extension* FindOrNullInLargeMap(int key);
 
   // Inserts a new (key, Extension) into the ExtensionSet (and returns true), or
   // finds the already-existing Extension for that key (returns false).
   // The Extension* will point to the new-or-found Extension.
   std::pair<Extension*, bool> Insert(int key);
   // Same as insert for the large map.
   std::pair<Extension*, bool> InternalInsertIntoLargeMap(int key);
 
   // Grows the flat_capacity_.
   // If flat_capacity_ > kMaximumFlatCapacity, converts to LargeMap.
   void GrowCapacity(size_t minimum_new_capacity);
 
   static constexpr uint16_t kMaximumFlatCapacity = 256;
 
   // Reserves capacity for the flat_capacity_ when the ExtensionSet is
   // IsCompletelyEmpty.
   // minimum_new_capacity must be <= kMaximumFlatCapacity.
   void InternalReserveSmallCapacityFromEmpty(size_t minimum_new_capacity);
 
   bool is_large() const { return static_cast<int16_t>(flat_size_) < 0; }
 
   // Removes a key from the ExtensionSet.
   void Erase(int key);
 
   // Returns the number of elements in the ExtensionSet, including cleared
   // extensions.
   size_t Size() const {
     return ABSL_PREDICT_FALSE(is_large()) ? map_.large->size() : flat_size_;
   }
 
   // For use as `PrefetchFunctor`s in `ForEach`.
   struct Prefetch {
     void operator()(const void* ptr) const { absl::PrefetchToLocalCache(ptr); }
   };
   struct PrefetchNta {
     void operator()(const void* ptr) const {
       absl::PrefetchToLocalCacheNta(ptr);
     }
   };
 
   template <typename Iterator, typename KeyValueFunctor,
             typename PrefetchFunctor>
   static void ForEachPrefetchImpl(Iterator it, Iterator end,
                                   KeyValueFunctor func,
                                   PrefetchFunctor prefetch_func) {
     // Note: based on arena's ChunkList::Cleanup().
     // Prefetch distance 16 performs better than 8 in load tests.
     constexpr int kPrefetchDistance = 16;
     Iterator prefetch = it;
     // Prefetch the first kPrefetchDistance extensions.
     for (int i = 0; prefetch != end && i < kPrefetchDistance; ++prefetch, ++i) {
       prefetch_func(prefetch->second.PrefetchPtr());
     }
     // For the middle extensions, call func and then prefetch the extension
     // kPrefetchDistance after the current one.
     for (; prefetch != end; ++it, ++prefetch) {
       func(it->first, it->second);
       prefetch_func(prefetch->second.PrefetchPtr());
     }
     // Call func on the rest without prefetching.
     for (; it != end; ++it) func(it->first, it->second);
   }
 
   // Similar to std::for_each, but returning void.
   // Each Iterator is decomposed into ->first and ->second fields, so
   // that the KeyValueFunctor can be agnostic vis-a-vis KeyValue-vs-std::pair.
   // Applies a functor to the <int, Extension&> pairs in sorted order and
   // prefetches ahead.
   template <typename KeyValueFunctor, typename PrefetchFunctor>
   void ForEach(KeyValueFunctor func, PrefetchFunctor prefetch_func) {
     if (ABSL_PREDICT_FALSE(is_large())) {
       ForEachPrefetchImpl(map_.large->begin(), map_.large->end(),
                           std::move(func), std::move(prefetch_func));
       return;
     }
     ForEachPrefetchImpl(flat_begin(), flat_end(), std::move(func),
                         std::move(prefetch_func));
   }
   // As above, but const.
   template <typename KeyValueFunctor, typename PrefetchFunctor>
   void ForEach(KeyValueFunctor func, PrefetchFunctor prefetch_func) const {
     if (ABSL_PREDICT_FALSE(is_large())) {
       ForEachPrefetchImpl(map_.large->begin(), map_.large->end(),
                           std::move(func), std::move(prefetch_func));
       return;
     }
     ForEachPrefetchImpl(flat_begin(), flat_end(), std::move(func),
                         std::move(prefetch_func));
   }
 
   // As above, but without prefetching. This is for use in cases where we never
   // use the pointed-to extension values in `func`.
   template <typename Iterator, typename KeyValueFunctor>
   static void ForEachNoPrefetch(Iterator begin, Iterator end,
                                 KeyValueFunctor func) {
     for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
   }
 
   // Applies a functor to the <int, Extension&> pairs in sorted order.
   template <typename KeyValueFunctor>
   void ForEachNoPrefetch(KeyValueFunctor func) {
     if (ABSL_PREDICT_FALSE(is_large())) {
       ForEachNoPrefetch(map_.large->begin(), map_.large->end(),
                         std::move(func));
       return;
     }
     ForEachNoPrefetch(flat_begin(), flat_end(), std::move(func));
   }
 
   // As above, but const.
   template <typename KeyValueFunctor>
   void ForEachNoPrefetch(KeyValueFunctor func) const {
     if (ABSL_PREDICT_FALSE(is_large())) {
       ForEachNoPrefetch(map_.large->begin(), map_.large->end(),
                         std::move(func));
       return;
     }
     ForEachNoPrefetch(flat_begin(), flat_end(), std::move(func));
   }
 
   // Returns true if nothing is allocated in the ExtensionSet.
   bool IsCompletelyEmpty() const {
     return flat_size_ == 0 && flat_capacity_ == 0;
   }
 
   // Implementation of MergeFrom into the empty ExtensionSet from a small
   // `other`.
   // This is used in all types of copy.
   // PRECONDITIONs:
   // 1. `this.IsCompletelyEmpty()`.
   // 2. `other` is small (!other.is_large()).
   void InternalMergeFromSmallToEmpty(const MessageLite* extendee,
                                      const ExtensionSet& other);
   // Implementation of MergeFrom for general case.
   void InternalMergeFromSlow(const MessageLite* extendee,
                              const ExtensionSet& other);
   // Merges new or existing Extension from other_extension.
   void InternalExtensionMergeFrom(const MessageLite* extendee, int number,
                                   const Extension& other_extension,
                                   Arena* other_arena);
   // Merges newly created uninitialized Extension from other_extension.
   void InternalExtensionMergeFromIntoUninitializedExtension(
       Extension& dst_extension, const MessageLite* extendee, int number,
       const Extension& other_extension, Arena* other_arena);
 
   inline static bool is_packable(WireFormatLite::WireType type) {
     switch (type) {
       case WireFormatLite::WIRETYPE_VARINT:
       case WireFormatLite::WIRETYPE_FIXED64:
       case WireFormatLite::WIRETYPE_FIXED32:
         return true;
       case WireFormatLite::WIRETYPE_LENGTH_DELIMITED:
       case WireFormatLite::WIRETYPE_START_GROUP:
       case WireFormatLite::WIRETYPE_END_GROUP:
         return false;
 
         // Do not add a default statement. Let the compiler complain when
         // someone
         // adds a new wire type.
     }
     Unreachable();  // switch handles all possible enum values
     return false;
   }
 
   // Returns true and fills field_number and extension if extension is found.
   // Note to support packed repeated field compatibility, it also fills whether
   // the tag on wire is packed, which can be different from
   // extension->is_packed (whether packed=true is specified).
   template <typename ExtensionFinder>
   bool FindExtensionInfoFromTag(uint32_t tag, ExtensionFinder* extension_finder,
                                 int* field_number, ExtensionInfo* extension,
                                 bool* was_packed_on_wire) {
     *field_number = WireFormatLite::GetTagFieldNumber(tag);
     WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
     return FindExtensionInfoFromFieldNumber(wire_type, *field_number,
                                             extension_finder, extension,
                                             was_packed_on_wire);
   }
 
   // Returns true and fills extension if extension is found.
   // Note to support packed repeated field compatibility, it also fills whether
   // the tag on wire is packed, which can be different from
   // extension->is_packed (whether packed=true is specified).
   template <typename ExtensionFinder>
   bool FindExtensionInfoFromFieldNumber(int wire_type, int field_number,
                                         ExtensionFinder* extension_finder,
                                         ExtensionInfo* extension,
                                         bool* was_packed_on_wire) const {
     if (!extension_finder->Find(field_number, extension)) {
       return false;
     }
 
     ABSL_DCHECK(extension->type > 0 &&
                 extension->type <= WireFormatLite::MAX_FIELD_TYPE);
     auto real_type = static_cast<WireFormatLite::FieldType>(extension->type);
 
     WireFormatLite::WireType expected_wire_type =
         WireFormatLite::WireTypeForFieldType(real_type);
 
     // Check if this is a packed field.
     *was_packed_on_wire = false;
     if (extension->is_repeated &&
         wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED &&
         is_packable(expected_wire_type)) {
       *was_packed_on_wire = true;
       return true;
     }
     // Otherwise the wire type must match.
     return expected_wire_type == wire_type;
   }
 
   // Find the prototype for a LazyMessage from the extension registry. Returns
   // null if the extension is not found.
   const MessageLite* GetPrototypeForLazyMessage(const MessageLite* extendee,
                                                 int number) const;
 
   // Returns true if extension is present and lazy.
   bool HasLazy(int number) const;
 
   // Gets the extension with the given number, creating it if it does not
   // already exist.  Returns true if the extension did not already exist.
   bool MaybeNewExtension(int number, const FieldDescriptor* descriptor,
                          Extension** result);
 
   // Gets the repeated extension for the given descriptor, creating it if
   // it does not exist.
   Extension* MaybeNewRepeatedExtension(const FieldDescriptor* descriptor);
 
   // If the extension exists, return it. Otherwise, create it first.
   // If `pointer_creator` is not null, it is called on creation.
   Extension& FindOrCreate(int number, FieldType type, bool repeated,
                           bool packed, const FieldDescriptor* descriptor,
                           Extension& (*pointer_creator)(Extension& ext,
                                                         Arena* arena));
 
   template <typename T>
   static Extension& CreateImpl(Extension& ext, Arena* arena) {
     ext.Mutable<T>() = Arena::Create<T>(arena);
     return ext;
   }
 
   bool FindExtension(int wire_type, uint32_t field, const MessageLite* extendee,
                      const internal::ParseContext* /*ctx*/,
                      ExtensionInfo* extension, bool* was_packed_on_wire) {
     GeneratedExtensionFinder finder(extendee);
     return FindExtensionInfoFromFieldNumber(wire_type, field, &finder,
                                             extension, was_packed_on_wire);
   }
   inline bool FindExtension(int wire_type, uint32_t field,
                             const Message* extendee,
                             const internal::ParseContext* ctx,
                             ExtensionInfo* extension, bool* was_packed_on_wire);
   // Used for MessageSet only
   const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr,
                                     const MessageLite* extendee,
                                     internal::InternalMetadata* metadata,
                                     internal::ParseContext* ctx) {
     // Lite MessageSet doesn't implement lazy.
     return ParseField(tag, ptr, extendee, metadata, ctx);
   }
   const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr,
                                     const Message* extendee,
                                     internal::InternalMetadata* metadata,
                                     internal::ParseContext* ctx);
   const char* ParseMessageSetItem(const char* ptr, const MessageLite* extendee,
                                   internal::InternalMetadata* metadata,
                                   internal::ParseContext* ctx);
   const char* ParseMessageSetItem(const char* ptr, const Message* extendee,
                                   internal::InternalMetadata* metadata,
                                   internal::ParseContext* ctx);
 
   // Implemented in extension_set_inl.h to keep code out of the header file.
   template <typename T>
   const char* ParseFieldWithExtensionInfo(int number, bool was_packed_on_wire,
                                           const ExtensionInfo& info,
                                           internal::InternalMetadata* metadata,
                                           const char* ptr,
                                           internal::ParseContext* ctx);
   template <typename Msg, typename T>
   const char* ParseMessageSetItemTmpl(const char* ptr, const Msg* extendee,
                                       internal::InternalMetadata* metadata,
                                       internal::ParseContext* ctx);
 
   // Hack:  RepeatedPtrFieldBase declares ExtensionSet as a friend.  This
   //   friendship should automatically extend to ExtensionSet::Extension, but
   //   unfortunately some older compilers (e.g. GCC 3.4.4) do not implement this
   //   correctly.  So, we must provide helpers for calling methods of that
   //   class.
 
   // Defined in extension_set_heavy.cc.
   static inline size_t RepeatedMessage_SpaceUsedExcludingSelfLong(
       RepeatedPtrFieldBase* field);
 
   KeyValue* flat_begin() {
     assert(!is_large());
     return map_.flat;
   }
   const KeyValue* flat_begin() const {
     assert(!is_large());
     return map_.flat;
   }
   KeyValue* flat_end() {
     assert(!is_large());
     return map_.flat + flat_size_;
   }
   const KeyValue* flat_end() const {
     assert(!is_large());
     return map_.flat + flat_size_;
   }
 
   static KeyValue* AllocateFlatMap(Arena* arena,
                                    uint16_t powerof2_flat_capacity);
   static void DeleteFlatMap(const KeyValue* flat, uint16_t flat_capacity);
 
   Arena* arena_;
 
   // Manual memory-management:
   // map_.flat is an allocated array of flat_capacity_ elements.
   // [map_.flat, map_.flat + flat_size_) is the currently-in-use prefix.
   uint16_t flat_capacity_;
   uint16_t flat_size_;  // negative int16_t(flat_size_) indicates is_large()
   union AllocatedData {
     KeyValue* flat;
 
     // If flat_capacity_ > kMaximumFlatCapacity, switch to LargeMap,
     // which guarantees O(n lg n) CPU but larger constant factors.
     LargeMap* large;
   } map_;
 };
 
 constexpr ExtensionSet::ExtensionSet(Arena* arena)
     : arena_(arena), flat_capacity_(0), flat_size_(0), map_{nullptr} {}
 
 // ===================================================================
 // Glue for generated extension accessors
 
 // -------------------------------------------------------------------
 // Template magic
 
 // First we have a set of classes representing "type traits" for different
 // field types.  A type traits class knows how to implement basic accessors
 // for extensions of a particular type given an ExtensionSet.  The signature
 // for a type traits class looks like this:
 //
 //   class TypeTraits {
 //    public:
 //     typedef ? ConstType;
 //     typedef ? MutableType;
 //     // TypeTraits for singular fields and repeated fields will define the
 //     // symbol "Singular" or "Repeated" respectively. These two symbols will
 //     // be used in extension accessors to distinguish between singular
 //     // extensions and repeated extensions. If the TypeTraits for the passed
 //     // in extension doesn't have the expected symbol defined, it means the
 //     // user is passing a repeated extension to a singular accessor, or the
 //     // opposite. In that case the C++ compiler will generate an error
 //     // message "no matching member function" to inform the user.
 //     typedef ? Singular
 //     typedef ? Repeated
 //
 //     static inline ConstType Get(int number, const ExtensionSet& set);
 //     static inline void Set(int number, ConstType value, ExtensionSet* set);
 //     static inline MutableType Mutable(int number, ExtensionSet* set);
 //
 //     // Variants for repeated fields.
 //     static inline ConstType Get(int number, const ExtensionSet& set,
 //                                 int index);
 //     static inline void Set(int number, int index,
 //                            ConstType value, ExtensionSet* set);
 //     static inline MutableType Mutable(int number, int index,
 //                                       ExtensionSet* set);
 //     static inline void Add(int number, ConstType value, ExtensionSet* set);
 //     static inline MutableType Add(int number, ExtensionSet* set);
 //     This is used by the ExtensionIdentifier constructor to register
 //     the extension at dynamic initialization.
 //   };
 //
 // Not all of these methods make sense for all field types.  For example, the
 // "Mutable" methods only make sense for strings and messages, and the
 // repeated methods only make sense for repeated types.  So, each type
 // traits class implements only the set of methods from this signature that it
 // actually supports.  This will cause a compiler error if the user tries to
 // access an extension using a method that doesn't make sense for its type.
 // For example, if "foo" is an extension of type "optional int32", then if you
 // try to write code like:
 //   my_message.MutableExtension(foo)
 // you will get a compile error because PrimitiveTypeTraits<int32_t> does not
 // have a "Mutable()" method.
 
 // -------------------------------------------------------------------
 // PrimitiveTypeTraits
 
 // Since the ExtensionSet has different methods for each primitive type,
 // we must explicitly define the methods of the type traits class for each
 // known type.
 template <typename Type>
 class PrimitiveTypeTraits {
  public:
   typedef Type ConstType;
   typedef Type MutableType;
   using InitType = ConstType;
   static const ConstType& FromInitType(const InitType& v) { return v; }
   typedef PrimitiveTypeTraits<Type> Singular;
   static constexpr bool kLifetimeBound = false;
 
   static inline ConstType Get(int number, const ExtensionSet& set,
                               ConstType default_value) {
     return set.Get<Type>(number, default_value);
   }
 
   static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
                                         const ConstType& default_value) {
     return &set.Get<Type>(number, default_value);
   }
   static inline void Set(int number, FieldType field_type, ConstType value,
                          ExtensionSet* set) {
     set->Set<Type>(number, field_type, value, nullptr);
   }
 };
 
 template <typename Type>
 class RepeatedPrimitiveTypeTraits {
  public:
   typedef Type ConstType;
   typedef Type MutableType;
   using InitType = ConstType;
   static const ConstType& FromInitType(const InitType& v) { return v; }
   typedef RepeatedPrimitiveTypeTraits<Type> Repeated;
   static constexpr bool kLifetimeBound = false;
 
   typedef RepeatedField<Type> RepeatedFieldType;
 
   static inline Type Get(int number, const ExtensionSet& set, int index) {
     return set.GetRepeated<Type>(number, index);
   }
   static inline const Type* GetPtr(int number, const ExtensionSet& set,
                                    int index) {
     return &set.GetRepeated<Type>(number, index);
   }
   static inline const RepeatedField<ConstType>* GetRepeatedPtr(
       int number, const ExtensionSet& set);
   static inline void Set(int number, int index, Type value, ExtensionSet* set) {
     set->SetRepeated<Type>(number, index, value);
   }
   static inline void Add(int number, FieldType field_type, bool is_packed,
                          Type value, ExtensionSet* set) {
     set->Add<Type>(number, field_type, is_packed, value, nullptr);
   }
 
   static inline const RepeatedField<ConstType>& GetRepeated(
       int number, const ExtensionSet& set);
   static inline RepeatedField<Type>* MutableRepeated(int number,
                                                      FieldType field_type,
                                                      bool is_packed,
                                                      ExtensionSet* set);
 
   static const RepeatedFieldType* GetDefaultRepeatedField();
 };
 
 class PROTOBUF_EXPORT RepeatedPrimitiveDefaults {
  private:
   template <typename Type>
   friend class RepeatedPrimitiveTypeTraits;
   static const RepeatedPrimitiveDefaults* default_instance();
   RepeatedField<int32_t> default_repeated_field_int32_t_;
   RepeatedField<int64_t> default_repeated_field_int64_t_;
   RepeatedField<uint32_t> default_repeated_field_uint32_t_;
   RepeatedField<uint64_t> default_repeated_field_uint64_t_;
   RepeatedField<double> default_repeated_field_double_;
   RepeatedField<float> default_repeated_field_float_;
   RepeatedField<bool> default_repeated_field_bool_;
 };
 
 #define PROTOBUF_DEFINE_PRIMITIVE_TYPE(TYPE, METHOD)                           \
   template <>                                                                  \
   inline const RepeatedField<TYPE>*                                            \
   RepeatedPrimitiveTypeTraits<TYPE>::GetDefaultRepeatedField() {               \
     return &RepeatedPrimitiveDefaults::default_instance()                      \
                 ->default_repeated_field_##TYPE##_;                            \
   }                                                                            \
   template <>                                                                  \
   inline const RepeatedField<TYPE>&                                            \
   RepeatedPrimitiveTypeTraits<TYPE>::GetRepeated(int number,                   \
                                                  const ExtensionSet& set) {    \
     return *reinterpret_cast<const RepeatedField<TYPE>*>(                      \
         set.GetRawRepeatedField(number, GetDefaultRepeatedField()));           \
   }                                                                            \
   template <>                                                                  \
   inline const RepeatedField<TYPE>*                                            \
   RepeatedPrimitiveTypeTraits<TYPE>::GetRepeatedPtr(int number,                \
                                                     const ExtensionSet& set) { \
     return &GetRepeated(number, set);                                          \
   }                                                                            \
   template <>                                                                  \
   inline RepeatedField<TYPE>*                                                  \
   RepeatedPrimitiveTypeTraits<TYPE>::MutableRepeated(                          \
       int number, FieldType field_type, bool is_packed, ExtensionSet* set) {   \
     return reinterpret_cast<RepeatedField<TYPE>*>(                             \
         set->MutableRawRepeatedField(number, field_type, is_packed, nullptr)); \
   }
 
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(int32_t, Int32)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(int64_t, Int64)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint32_t, UInt32)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint64_t, UInt64)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(float, Float)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(double, Double)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(bool, Bool)
 
 #undef PROTOBUF_DEFINE_PRIMITIVE_TYPE
 
 // -------------------------------------------------------------------
 // StringTypeTraits
 
 // Strings support both Set() and Mutable().
 class PROTOBUF_EXPORT StringTypeTraits {
  public:
   typedef const std::string& ConstType;
   typedef std::string* MutableType;
   using InitType = ConstType;
   static ConstType FromInitType(InitType v) { return v; }
   typedef StringTypeTraits Singular;
   static constexpr bool kLifetimeBound = true;
 
   static inline const std::string& Get(int number, const ExtensionSet& set,
                                        ConstType default_value) {
     return set.Get<std::string>(number, default_value);
   }
   static inline const std::string* GetPtr(int number, const ExtensionSet& set,
                                           ConstType default_value) {
     return &Get(number, set, default_value);
   }
   static inline void Set(int number, FieldType field_type,
                          const std::string& value, ExtensionSet* set) {
     set->Set<std::string>(number, field_type, value, nullptr);
   }
   static inline std::string* Mutable(int number, FieldType field_type,
                                      ExtensionSet* set) {
     return set->MutableString(number, field_type, nullptr);
   }
 };
 
 class PROTOBUF_EXPORT RepeatedStringTypeTraits {
  public:
   typedef const std::string& ConstType;
   typedef std::string* MutableType;
   using InitType = ConstType;
   static ConstType FromInitType(InitType v) { return v; }
   typedef RepeatedStringTypeTraits Repeated;
   static constexpr bool kLifetimeBound = true;
 
   typedef RepeatedPtrField<std::string> RepeatedFieldType;
 
   static inline const std::string& Get(int number, const ExtensionSet& set,
                                        int index) {
     return set.GetRepeated<std::string>(number, index);
   }
   static inline const std::string* GetPtr(int number, const ExtensionSet& set,
                                           int index) {
     return &Get(number, set, index);
   }
   static inline const RepeatedPtrField<std::string>* GetRepeatedPtr(
       int number, const ExtensionSet& set) {
     return &GetRepeated(number, set);
   }
   static inline void Set(int number, int index, const std::string& value,
                          ExtensionSet* set) {
     set->SetRepeated<std::string>(number, index, value);
   }
   static inline std::string* Mutable(int number, int index, ExtensionSet* set) {
     return set->MutableRepeatedString(number, index);
   }
   static inline void Add(int number, FieldType field_type, bool /*is_packed*/,
                          const std::string& value, ExtensionSet* set) {
     set->Add<std::string>(number, field_type, nullptr) = value;
   }
   static inline std::string* Add(int number, FieldType field_type,
                                  ExtensionSet* set) {
     return &set->Add<std::string>(number, field_type, nullptr);
   }
 
   static inline const RepeatedPtrField<std::string>& GetRepeated(
       int number, const ExtensionSet& set) {
     return *reinterpret_cast<const RepeatedPtrField<std::string>*>(
         set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
   }
 
   static inline RepeatedPtrField<std::string>* MutableRepeated(
       int number, FieldType field_type, bool is_packed, ExtensionSet* set) {
     return reinterpret_cast<RepeatedPtrField<std::string>*>(
         set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
   }
 
   static const RepeatedFieldType* GetDefaultRepeatedField();
 
  private:
   static void InitializeDefaultRepeatedFields();
   static void DestroyDefaultRepeatedFields();
 };
 
 // -------------------------------------------------------------------
 // EnumTypeTraits
 
 // ExtensionSet represents enums using integers internally, so we have to
 // static_cast around.
 template <typename Type>
 class EnumTypeTraits {
  public:
   typedef Type ConstType;
   typedef Type MutableType;
   using InitType = ConstType;
   static const ConstType& FromInitType(const InitType& v) { return v; }
   typedef EnumTypeTraits<Type> Singular;
   static constexpr bool kLifetimeBound = false;
 
   static inline ConstType Get(int number, const ExtensionSet& set,
                               ConstType default_value) {
     return static_cast<Type>(set.Get<int>(number, default_value));
   }
   static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
                                         const ConstType& default_value) {
     return reinterpret_cast<const Type*>(&set.Get<int>(number, default_value));
   }
   static inline void Set(int number, FieldType field_type, ConstType value,
                          ExtensionSet* set) {
     ABSL_DCHECK(
         internal::ValidateEnum(value, EnumTraits<Type>::validation_data()));
     set->Set<int>(number, field_type, value, nullptr);
   }
 };
 
 template <typename Type>
 class RepeatedEnumTypeTraits {
  public:
   typedef Type ConstType;
   typedef Type MutableType;
   using InitType = ConstType;
   static const ConstType& FromInitType(const InitType& v) { return v; }
   typedef RepeatedEnumTypeTraits<Type> Repeated;
   static constexpr bool kLifetimeBound = false;
 
   typedef RepeatedField<Type> RepeatedFieldType;
 
   static inline ConstType Get(int number, const ExtensionSet& set, int index) {
     return static_cast<Type>(set.GetRepeated<int>(number, index));
   }
   static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
                                         int index) {
     return reinterpret_cast<const Type*>(&set.GetRepeated<int>(number, index));
   }
   static inline void Set(int number, int index, ConstType value,
                          ExtensionSet* set) {
     ABSL_DCHECK(
         internal::ValidateEnum(value, EnumTraits<Type>::validation_data()));
     set->SetRepeated<int>(number, index, value);
   }
   static inline void Add(int number, FieldType field_type, bool is_packed,
                          ConstType value, ExtensionSet* set) {
     ABSL_DCHECK(
         internal::ValidateEnum(value, EnumTraits<Type>::validation_data()));
     set->Add<int>(number, field_type, is_packed, value, nullptr);
   }
   static inline const RepeatedField<Type>& GetRepeated(
       int number, const ExtensionSet& set) {
     // Hack: the `Extension` struct stores a RepeatedField<int> for enums.
     // RepeatedField<int> cannot implicitly convert to RepeatedField<EnumType>
     // so we need to do some casting magic. See message.h for similar
     // contortions for non-extension fields.
     return *reinterpret_cast<const RepeatedField<Type>*>(
         set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
   }
   static inline const RepeatedField<Type>* GetRepeatedPtr(
       int number, const ExtensionSet& set) {
     return &GetRepeated(number, set);
   }
   static inline RepeatedField<Type>* MutableRepeated(int number,
                                                      FieldType field_type,
                                                      bool is_packed,
                                                      ExtensionSet* set) {
     return reinterpret_cast<RepeatedField<Type>*>(
         set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
   }
 
   static const RepeatedFieldType* GetDefaultRepeatedField() {
     // Hack: as noted above, repeated enum fields are internally stored as a
     // RepeatedField<int>. We need to be able to instantiate global static
     // objects to return as default (empty) repeated fields on non-existent
     // extensions. We would not be able to know a-priori all of the enum types
     // (values of |Type|) to instantiate all of these, so we just re-use
     // int32_t's default repeated field object.
     return reinterpret_cast<const RepeatedField<Type>*>(
         RepeatedPrimitiveTypeTraits<int32_t>::GetDefaultRepeatedField());
   }
 };
 
 // -------------------------------------------------------------------
 // MessageTypeTraits
 
 // ExtensionSet guarantees that when manipulating extensions with message
 // types, the implementation used will be the compiled-in class representing
 // that type.  So, we can static_cast down to the exact type we expect.
 template <typename Type>
 class MessageTypeTraits {
  public:
   typedef const Type& ConstType;
   typedef Type* MutableType;
   using InitType = const void*;
   static ConstType FromInitType(InitType v) {
     return *static_cast<const Type*>(v);
   }
   typedef MessageTypeTraits<Type> Singular;
   static constexpr bool kLifetimeBound = true;
 
   static inline ConstType Get(int number, const ExtensionSet& set,
                               ConstType default_value) {
     return static_cast<const Type&>(set.GetMessage(number, default_value));
   }
   static inline std::nullptr_t GetPtr(int /* number */,
                                       const ExtensionSet& /* set */,
                                       ConstType /* default_value */) {
     // Cannot be implemented because of forward declared messages?
     return nullptr;
   }
   static inline MutableType Mutable(int number, FieldType field_type,
                                     ExtensionSet* set) {
     return static_cast<Type*>(set->MutableMessage(
         number, field_type, Type::default_instance(), nullptr));
   }
   static inline void SetAllocated(int number, FieldType field_type,
                                   MutableType message, ExtensionSet* set) {
     set->SetAllocatedMessage(number, field_type, nullptr, message);
   }
   static inline void UnsafeArenaSetAllocated(int number, FieldType field_type,
                                              MutableType message,
                                              ExtensionSet* set) {
     set->UnsafeArenaSetAllocatedMessage(number, field_type, nullptr, message);
   }
   [[nodiscard]] static inline MutableType Release(int number,
                                                   FieldType /* field_type */,
                                                   ExtensionSet* set) {
     return static_cast<Type*>(
         set->ReleaseMessage(number, Type::default_instance()));
   }
   static inline MutableType UnsafeArenaRelease(int number,
                                                FieldType /* field_type */,
                                                ExtensionSet* set) {
     return static_cast<Type*>(
         set->UnsafeArenaReleaseMessage(number, Type::default_instance()));
   }
 };
 
 // Used by WireFormatVerify to extract the verify function from the registry.
 LazyEagerVerifyFnType FindExtensionLazyEagerVerifyFn(
     const MessageLite* extendee, int number);
 
 // forward declaration.
 class RepeatedMessageGenericTypeTraits;
 
 template <typename Type>
 class RepeatedMessageTypeTraits {
  public:
   typedef const Type& ConstType;
   typedef Type* MutableType;
   using InitType = const void*;
   static ConstType FromInitType(InitType v) {
     return *static_cast<const Type*>(v);
   }
   typedef RepeatedMessageTypeTraits<Type> Repeated;
   static constexpr bool kLifetimeBound = true;
 
   typedef RepeatedPtrField<Type> RepeatedFieldType;
 
   static inline ConstType Get(int number, const ExtensionSet& set, int index) {
     return static_cast<const Type&>(set.GetRepeatedMessage(number, index));
   }
   static inline std::nullptr_t GetPtr(int /* number */,
                                       const ExtensionSet& /* set */,
                                       int /* index */) {
     // Cannot be implemented because of forward declared messages?
     return nullptr;
   }
   static inline std::nullptr_t GetRepeatedPtr(int /* number */,
                                               const ExtensionSet& /* set */) {
     // Cannot be implemented because of forward declared messages?
     return nullptr;
   }
   static inline MutableType Mutable(int number, int index, ExtensionSet* set) {
     return static_cast<Type*>(set->MutableRepeatedMessage(number, index));
   }
   static inline MutableType Add(int number, FieldType field_type,
                                 ExtensionSet* set) {
     static const ClassData* class_data = MessageTraits<Type>::class_data();
     return static_cast<Type*>(
         set->AddMessage(number, field_type, class_data, nullptr));
   }
   static inline const RepeatedPtrField<Type>& GetRepeated(
       int number, const ExtensionSet& set) {
     // See notes above in RepeatedEnumTypeTraits::GetRepeated(): same
     // casting hack applies here, because a RepeatedPtrField<MessageLite>
     // cannot naturally become a RepeatedPtrType<Type> even though Type is
     // presumably a message. google::protobuf::Message goes through similar contortions
     // with a reinterpret_cast<>.
     return *reinterpret_cast<const RepeatedPtrField<Type>*>(
         set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
   }
   static inline RepeatedPtrField<Type>* MutableRepeated(int number,
                                                         FieldType field_type,
                                                         bool is_packed,
                                                         ExtensionSet* set) {
     return reinterpret_cast<RepeatedPtrField<Type>*>(
         set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
   }
 
   static const RepeatedFieldType* GetDefaultRepeatedField();
 };
 
 template <typename Type>
 inline const typename RepeatedMessageTypeTraits<Type>::RepeatedFieldType*
 RepeatedMessageTypeTraits<Type>::GetDefaultRepeatedField() {
   static auto instance = OnShutdownDelete(new RepeatedFieldType);
   return instance;
 }
 
 // -------------------------------------------------------------------
 // ExtensionIdentifier
 
 // This is the type of actual extension objects.  E.g. if you have:
 //   extend Foo {
 //     optional int32 bar = 1234;
 //   }
 // then "bar" will be defined in C++ as:
 //   ExtensionIdentifier<Foo, PrimitiveTypeTraits<int32_t>, 5, false> bar(1234);
 //
 // Note that we could, in theory, supply the field number as a template
 // parameter, and thus make an instance of ExtensionIdentifier have no
 // actual contents.  However, if we did that, then using an extension
 // identifier would not necessarily cause the compiler to output any sort
 // of reference to any symbol defined in the extension's .pb.o file.  Some
 // linkers will actually drop object files that are not explicitly referenced,
 // but that would be bad because it would cause this extension to not be
 // registered at static initialization, and therefore using it would crash.
 
 template <typename ExtendeeType, typename TypeTraitsType, FieldType field_type,
           bool is_packed>
 class ExtensionIdentifier {
  public:
   typedef TypeTraitsType TypeTraits;
   typedef ExtendeeType Extendee;
 
   constexpr ExtensionIdentifier(int number,
                                 typename TypeTraits::InitType default_value)
       : number_(number), default_value_(default_value) {}
 
   inline int number() const { return number_; }
   typename TypeTraits::ConstType default_value() const {
     return TypeTraits::FromInitType(default_value_);
   }
 
   typename TypeTraits::ConstType const& default_value_ref() const {
     return TypeTraits::FromInitType(default_value_);
   }
 
  private:
   const int number_;
   typename TypeTraits::InitType default_value_;
 };
 
 // -------------------------------------------------------------------
 // Generated accessors
 
 
 }  // namespace internal
 
 // Call this function to ensure that this extensions's reflection is linked into
 // the binary:
 //
 //   google::protobuf::LinkExtensionReflection(Foo::my_extension);
 //
 // This will ensure that the following lookup will succeed:
 //
 //   DescriptorPool::generated_pool()->FindExtensionByName("Foo.my_extension");
 //
 // This is often relevant for parsing extensions in text mode.
 //
 // As a side-effect, it will also guarantee that anything else from the same
 // .proto file will also be available for lookup in the generated pool.
 //
 // This function does not actually register the extension, so it does not need
 // to be called before the lookup.  However it does need to occur in a function
 // that cannot be stripped from the binary (ie. it must be reachable from main).
 //
 // Best practice is to call this function as close as possible to where the
 // reflection is actually needed.  This function is very cheap to call, so you
 // should not need to worry about its runtime overhead except in tight loops (on
 // x86-64 it compiles into two "mov" instructions).
 template <typename ExtendeeType, typename TypeTraitsType,
           internal::FieldType field_type, bool is_packed>
 void LinkExtensionReflection(
     const google::protobuf::internal::ExtensionIdentifier<
         ExtendeeType, TypeTraitsType, field_type, is_packed>& extension) {
   internal::StrongReference(extension);
 }
 
 // Returns the field descriptor for a generated extension identifier.  This is
 // useful when doing reflection over generated extensions.
 template <typename ExtendeeType, typename TypeTraitsType,
           internal::FieldType field_type, bool is_packed,
           typename PoolType = DescriptorPool>
 const FieldDescriptor* GetExtensionReflection(
     const google::protobuf::internal::ExtensionIdentifier<
         ExtendeeType, TypeTraitsType, field_type, is_packed>& extension) {
   return PoolType::generated_pool()->FindExtensionByNumber(
       google::protobuf::internal::ExtensionIdentifier<ExtendeeType, TypeTraitsType,
                                             field_type,
                                             is_packed>::Extendee::descriptor(),
       extension.number());
 }
 
 }  // namespace protobuf
 }  // namespace google
 
 #include "google/protobuf/port_undef.inc"
 
 #endif  // GOOGLE_PROTOBUF_EXTENSION_SET_H__

This page was automatically generated by the 2.3.7 LXR engine. The LXR team