THUAI6/CAPI/cpp/grpc/include/google/protobuf/message.h

// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Author: kenton@google.com (Kenton Varda)
//  Based on original Protocol Buffers design by
//  Sanjay Ghemawat, Jeff Dean, and others.
//
// Defines Message, the abstract interface implemented by non-lite
// protocol message objects.  Although it's possible to implement this
// interface manually, most users will use the protocol compiler to
// generate implementations.
//
// Example usage:
//
// Say you have a message defined as:
//
//   message Foo {
//     optional string text = 1;
//     repeated int32 numbers = 2;
//   }
//
// Then, if you used the protocol compiler to generate a class from the above
// definition, you could use it like so:
//
//   std::string data;  // Will store a serialized version of the message.
//
//   {
//     // Create a message and serialize it.
//     Foo foo;
//     foo.set_text("Hello World!");
//     foo.add_numbers(1);
//     foo.add_numbers(5);
//     foo.add_numbers(42);
//
//     foo.SerializeToString(&data);
//   }
//
//   {
//     // Parse the serialized message and check that it contains the
//     // correct data.
//     Foo foo;
//     foo.ParseFromString(data);
//
//     assert(foo.text() == "Hello World!");
//     assert(foo.numbers_size() == 3);
//     assert(foo.numbers(0) == 1);
//     assert(foo.numbers(1) == 5);
//     assert(foo.numbers(2) == 42);
//   }
//
//   {
//     // Same as the last block, but do it dynamically via the Message
//     // reflection interface.
//     Message* foo = new Foo;
//     const Descriptor* descriptor = foo->GetDescriptor();
//
//     // Get the descriptors for the fields we're interested in and verify
//     // their types.
//     const FieldDescriptor* text_field = descriptor->FindFieldByName("text");
//     assert(text_field != nullptr);
//     assert(text_field->type() == FieldDescriptor::TYPE_STRING);
//     assert(text_field->label() == FieldDescriptor::LABEL_OPTIONAL);
//     const FieldDescriptor* numbers_field = descriptor->
//                                            FindFieldByName("numbers");
//     assert(numbers_field != nullptr);
//     assert(numbers_field->type() == FieldDescriptor::TYPE_INT32);
//     assert(numbers_field->label() == FieldDescriptor::LABEL_REPEATED);
//
//     // Parse the message.
//     foo->ParseFromString(data);
//
//     // Use the reflection interface to examine the contents.
//     const Reflection* reflection = foo->GetReflection();
//     assert(reflection->GetString(*foo, text_field) == "Hello World!");
//     assert(reflection->FieldSize(*foo, numbers_field) == 3);
//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 0) == 1);
//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 1) == 5);
//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 2) == 42);
//
//     delete foo;
//   }

#ifndef GOOGLE_PROTOBUF_MESSAGE_H__
#define GOOGLE_PROTOBUF_MESSAGE_H__

#include <iosfwd>
#include <string>
#include <type_traits>
#include <vector>

#include <google/protobuf/stubs/casts.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/port.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/map.h>  // TODO(b/211442718): cleanup
#include <google/protobuf/message_lite.h>

// Must be included last.
#include <google/protobuf/port_def.inc>

#ifdef SWIG
#error "You cannot SWIG proto headers"
#endif

namespace google
{
    namespace protobuf
    {

        // Defined in this file.
        class Message;
        class Reflection;
        class MessageFactory;

        // Defined in other files.
        class AssignDescriptorsHelper;
        class DynamicMessageFactory;
        class GeneratedMessageReflectionTestHelper;
        class MapKey;
        class MapValueConstRef;
        class MapValueRef;
        class MapIterator;
        class MapReflectionTester;

        namespace internal
        {
            struct DescriptorTable;
            class MapFieldBase;
            class SwapFieldHelper;
            class CachedSize;
        }                       // namespace internal
        class UnknownFieldSet;  // unknown_field_set.h
        namespace io
        {
            class ZeroCopyInputStream;   // zero_copy_stream.h
            class ZeroCopyOutputStream;  // zero_copy_stream.h
            class CodedInputStream;      // coded_stream.h
            class CodedOutputStream;     // coded_stream.h
        }                                // namespace io
        namespace python
        {
            class MapReflectionFriend;  // scalar_map_container.h
            class MessageReflectionFriend;
        }  // namespace python
        namespace expr
        {
            class CelMapReflectionFriend;  // field_backed_map_impl.cc
        }

        namespace internal
        {
            class MapFieldPrinterHelper;  // text_format.cc
        }
        namespace util
        {
            class MessageDifferencer;
        }

        namespace internal
        {
            class ReflectionAccessor;      // message.cc
            class ReflectionOps;           // reflection_ops.h
            class MapKeySorter;            // wire_format.cc
            class WireFormat;              // wire_format.h
            class MapFieldReflectionTest;  // map_test.cc
        }                                  // namespace internal

        template<typename T>
        class RepeatedField;  // repeated_field.h

        template<typename T>
        class RepeatedPtrField;  // repeated_field.h

        // A container to hold message metadata.
        struct Metadata
        {
            const Descriptor* descriptor;
            const Reflection* reflection;
        };

        namespace internal
        {
            template<class To>
            inline To* GetPointerAtOffset(Message* message, uint32_t offset)
            {
                return reinterpret_cast<To*>(reinterpret_cast<char*>(message) + offset);
            }

            template<class To>
            const To* GetConstPointerAtOffset(const Message* message, uint32_t offset)
            {
                return reinterpret_cast<const To*>(reinterpret_cast<const char*>(message) + offset);
            }

            template<class To>
            const To& GetConstRefAtOffset(const Message& message, uint32_t offset)
            {
                return *GetConstPointerAtOffset<To>(&message, offset);
            }

            bool CreateUnknownEnumValues(const FieldDescriptor* field);

            // Returns true if "message" is a descendant of "root".
            PROTOBUF_EXPORT bool IsDescendant(Message& root, const Message& message);
        }  // namespace internal

        // Abstract interface for protocol messages.
        //
        // See also MessageLite, which contains most every-day operations.  Message
        // adds descriptors and reflection on top of that.
        //
        // The methods of this class that are virtual but not pure-virtual have
        // default implementations based on reflection.  Message classes which are
        // optimized for speed will want to override these with faster implementations,
        // but classes optimized for code size may be happy with keeping them.  See
        // the optimize_for option in descriptor.proto.
        //
        // Users must not derive from this class. Only the protocol compiler and
        // the internal library are allowed to create subclasses.
        class PROTOBUF_EXPORT Message : public MessageLite
        {
        public:
            constexpr Message()
            {
            }

            // Basic Operations ------------------------------------------------

            // Construct a new instance of the same type.  Ownership is passed to the
            // caller.  (This is also defined in MessageLite, but is defined again here
            // for return-type covariance.)
            Message* New() const
            {
                return New(nullptr);
            }

            // Construct a new instance on the arena. Ownership is passed to the caller
            // if arena is a nullptr.
            Message* New(Arena* arena) const override = 0;

            // Make this message into a copy of the given message.  The given message
            // must have the same descriptor, but need not necessarily be the same class.
            // By default this is just implemented as "Clear(); MergeFrom(from);".
            void CopyFrom(const Message& from);

            // Merge the fields from the given message into this message.  Singular
            // fields will be overwritten, if specified in from, except for embedded
            // messages which will be merged.  Repeated fields will be concatenated.
            // The given message must be of the same type as this message (i.e. the
            // exact same class).
            virtual void MergeFrom(const Message& from);

            // Verifies that IsInitialized() returns true.  GOOGLE_CHECK-fails otherwise, with
            // a nice error message.
            void CheckInitialized() const;

            // Slowly build a list of all required fields that are not set.
            // This is much, much slower than IsInitialized() as it is implemented
            // purely via reflection.  Generally, you should not call this unless you
            // have already determined that an error exists by calling IsInitialized().
            void FindInitializationErrors(std::vector<std::string>* errors) const;

            // Like FindInitializationErrors, but joins all the strings, delimited by
            // commas, and returns them.
            std::string InitializationErrorString() const override;

            // Clears all unknown fields from this message and all embedded messages.
            // Normally, if unknown tag numbers are encountered when parsing a message,
            // the tag and value are stored in the message's UnknownFieldSet and
            // then written back out when the message is serialized.  This allows servers
            // which simply route messages to other servers to pass through messages
            // that have new field definitions which they don't yet know about.  However,
            // this behavior can have security implications.  To avoid it, call this
            // method after parsing.
            //
            // See Reflection::GetUnknownFields() for more on unknown fields.
            void DiscardUnknownFields();

            // Computes (an estimate of) the total number of bytes currently used for
            // storing the message in memory.  The default implementation calls the
            // Reflection object's SpaceUsed() method.
            //
            // SpaceUsed() is noticeably slower than ByteSize(), as it is implemented
            // using reflection (rather than the generated code implementation for
            // ByteSize()). Like ByteSize(), its CPU time is linear in the number of
            // fields defined for the proto.
            virtual size_t SpaceUsedLong() const;

            PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
            int SpaceUsed() const
            {
                return internal::ToIntSize(SpaceUsedLong());
            }

            // Debugging & Testing----------------------------------------------

            // Generates a human-readable form of this message for debugging purposes.
            // Note that the format and content of a debug string is not guaranteed, may
            // change without notice, and should not be depended on. Code that does
            // anything except display a string to assist in debugging should use
            // TextFormat instead.
            std::string DebugString() const;
            // Like DebugString(), but with less whitespace.
            std::string ShortDebugString() const;
            // Like DebugString(), but do not escape UTF-8 byte sequences.
            std::string Utf8DebugString() const;
            // Convenience function useful in GDB.  Prints DebugString() to stdout.
            void PrintDebugString() const;

            // Reflection-based methods ----------------------------------------
            // These methods are pure-virtual in MessageLite, but Message provides
            // reflection-based default implementations.

            std::string GetTypeName() const override;
            void Clear() override;

            // Returns whether all required fields have been set. Note that required
            // fields no longer exist starting in proto3.
            bool IsInitialized() const override;

            void CheckTypeAndMergeFrom(const MessageLite& other) override;
            // Reflective parser
            const char* _InternalParse(const char* ptr, internal::ParseContext* ctx) override;
            size_t ByteSizeLong() const override;
            uint8_t* _InternalSerialize(uint8_t* target, io::EpsCopyOutputStream* stream) const override;

        private:
            // This is called only by the default implementation of ByteSize(), to
            // update the cached size.  If you override ByteSize(), you do not need
            // to override this.  If you do not override ByteSize(), you MUST override
            // this; the default implementation will crash.
            //
            // The method is private because subclasses should never call it; only
            // override it.  Yes, C++ lets you do that.  Crazy, huh?
            virtual void SetCachedSize(int size) const;

        public:
            // Introspection ---------------------------------------------------

            // Get a non-owning pointer to a Descriptor for this message's type.  This
            // describes what fields the message contains, the types of those fields, etc.
            // This object remains property of the Message.
            const Descriptor* GetDescriptor() const
            {
                return GetMetadata().descriptor;
            }

            // Get a non-owning pointer to the Reflection interface for this Message,
            // which can be used to read and modify the fields of the Message dynamically
            // (in other words, without knowing the message type at compile time).  This
            // object remains property of the Message.
            const Reflection* GetReflection() const
            {
                return GetMetadata().reflection;
            }

        protected:
            // Get a struct containing the metadata for the Message, which is used in turn
            // to implement GetDescriptor() and GetReflection() above.
            virtual Metadata GetMetadata() const = 0;

            struct ClassData
            {
                // Note: The order of arguments (to, then from) is chosen so that the ABI
                // of this function is the same as the CopyFrom method.  That is, the
                // hidden "this" parameter comes first.
                void (*copy_to_from)(Message& to, const Message& from_msg);
                void (*merge_to_from)(Message& to, const Message& from_msg);
            };
            // GetClassData() returns a pointer to a ClassData struct which
            // exists in global memory and is unique to each subclass.  This uniqueness
            // property is used in order to quickly determine whether two messages are
            // of the same type.
            // TODO(jorg): change to pure virtual
            virtual const ClassData* GetClassData() const
            {
                return nullptr;
            }

            // CopyWithSourceCheck calls Clear() and then MergeFrom(), and in debug
            // builds, checks that calling Clear() on the destination message doesn't
            // alter the source.  It assumes the messages are known to be of the same
            // type, and thus uses GetClassData().
            static void CopyWithSourceCheck(Message& to, const Message& from);

            // Fail if "from" is a descendant of "to" as such copy is not allowed.
            static void FailIfCopyFromDescendant(Message& to, const Message& from);

            inline explicit Message(Arena* arena, bool is_message_owned = false) :
                MessageLite(arena, is_message_owned)
            {
            }
            size_t ComputeUnknownFieldsSize(size_t total_size, internal::CachedSize* cached_size) const;
            size_t MaybeComputeUnknownFieldsSize(size_t total_size, internal::CachedSize* cached_size) const;

        protected:
            static uint64_t GetInvariantPerBuild(uint64_t salt);

        private:
            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
        };

        namespace internal
        {
            // Forward-declare interfaces used to implement RepeatedFieldRef.
            // These are protobuf internals that users shouldn't care about.
            class RepeatedFieldAccessor;
        }  // namespace internal

        // Forward-declare RepeatedFieldRef templates. The second type parameter is
        // used for SFINAE tricks. Users should ignore it.
        template<typename T, typename Enable = void>
        class RepeatedFieldRef;

        template<typename T, typename Enable = void>
        class MutableRepeatedFieldRef;

        // This interface contains methods that can be used to dynamically access
        // and modify the fields of a protocol message.  Their semantics are
        // similar to the accessors the protocol compiler generates.
        //
        // To get the Reflection for a given Message, call Message::GetReflection().
        //
        // This interface is separate from Message only for efficiency reasons;
        // the vast majority of implementations of Message will share the same
        // implementation of Reflection (GeneratedMessageReflection,
        // defined in generated_message.h), and all Messages of a particular class
        // should share the same Reflection object (though you should not rely on
        // the latter fact).
        //
        // There are several ways that these methods can be used incorrectly.  For
        // example, any of the following conditions will lead to undefined
        // results (probably assertion failures):
        // - The FieldDescriptor is not a field of this message type.
        // - The method called is not appropriate for the field's type.  For
        //   each field type in FieldDescriptor::TYPE_*, there is only one
        //   Get*() method, one Set*() method, and one Add*() method that is
        //   valid for that type.  It should be obvious which (except maybe
        //   for TYPE_BYTES, which are represented using strings in C++).
        // - A Get*() or Set*() method for singular fields is called on a repeated
        //   field.
        // - GetRepeated*(), SetRepeated*(), or Add*() is called on a non-repeated
        //   field.
        // - The Message object passed to any method is not of the right type for
        //   this Reflection object (i.e. message.GetReflection() != reflection).
        //
        // You might wonder why there is not any abstract representation for a field
        // of arbitrary type.  E.g., why isn't there just a "GetField()" method that
        // returns "const Field&", where "Field" is some class with accessors like
        // "GetInt32Value()".  The problem is that someone would have to deal with
        // allocating these Field objects.  For generated message classes, having to
        // allocate space for an additional object to wrap every field would at least
        // double the message's memory footprint, probably worse.  Allocating the
        // objects on-demand, on the other hand, would be expensive and prone to
        // memory leaks.  So, instead we ended up with this flat interface.
        class PROTOBUF_EXPORT Reflection final
        {
        public:
            // Get the UnknownFieldSet for the message.  This contains fields which
            // were seen when the Message was parsed but were not recognized according
            // to the Message's definition.
            const UnknownFieldSet& GetUnknownFields(const Message& message) const;
            // Get a mutable pointer to the UnknownFieldSet for the message.  This
            // contains fields which were seen when the Message was parsed but were not
            // recognized according to the Message's definition.
            UnknownFieldSet* MutableUnknownFields(Message* message) const;

            // Estimate the amount of memory used by the message object.
            size_t SpaceUsedLong(const Message& message) const;

            PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
            int SpaceUsed(const Message& message) const
            {
                return internal::ToIntSize(SpaceUsedLong(message));
            }

            // Check if the given non-repeated field is set.
            bool HasField(const Message& message, const FieldDescriptor* field) const;

            // Get the number of elements of a repeated field.
            int FieldSize(const Message& message, const FieldDescriptor* field) const;

            // Clear the value of a field, so that HasField() returns false or
            // FieldSize() returns zero.
            void ClearField(Message* message, const FieldDescriptor* field) const;

            // Check if the oneof is set. Returns true if any field in oneof
            // is set, false otherwise.
            bool HasOneof(const Message& message, const OneofDescriptor* oneof_descriptor) const;

            void ClearOneof(Message* message, const OneofDescriptor* oneof_descriptor) const;

            // Returns the field descriptor if the oneof is set. nullptr otherwise.
            const FieldDescriptor* GetOneofFieldDescriptor(
                const Message& message, const OneofDescriptor* oneof_descriptor
            ) const;

            // Removes the last element of a repeated field.
            // We don't provide a way to remove any element other than the last
            // because it invites inefficient use, such as O(n^2) filtering loops
            // that should have been O(n).  If you want to remove an element other
            // than the last, the best way to do it is to re-arrange the elements
            // (using Swap()) so that the one you want removed is at the end, then
            // call RemoveLast().
            void RemoveLast(Message* message, const FieldDescriptor* field) const;
            // Removes the last element of a repeated message field, and returns the
            // pointer to the caller.  Caller takes ownership of the returned pointer.
            PROTOBUF_NODISCARD Message* ReleaseLast(Message* message, const FieldDescriptor* field) const;

            // Similar to ReleaseLast() without internal safety and ownershp checks. This
            // method should only be used when the objects are on the same arena or paired
            // with a call to `UnsafeArenaAddAllocatedMessage`.
            Message* UnsafeArenaReleaseLast(Message* message, const FieldDescriptor* field) const;

            // Swap the complete contents of two messages.
            void Swap(Message* message1, Message* message2) const;

            // Swap fields listed in fields vector of two messages.
            void SwapFields(Message* message1, Message* message2, const std::vector<const FieldDescriptor*>& fields) const;

            // Swap two elements of a repeated field.
            void SwapElements(Message* message, const FieldDescriptor* field, int index1, int index2) const;

            // Swap without internal safety and ownership checks. This method should only
            // be used when the objects are on the same arena.
            void UnsafeArenaSwap(Message* lhs, Message* rhs) const;

            // SwapFields without internal safety and ownership checks. This method should
            // only be used when the objects are on the same arena.
            void UnsafeArenaSwapFields(
                Message* lhs, Message* rhs, const std::vector<const FieldDescriptor*>& fields
            ) const;

            // List all fields of the message which are currently set, except for unknown
            // fields, but including extension known to the parser (i.e. compiled in).
            // Singular fields will only be listed if HasField(field) would return true
            // and repeated fields will only be listed if FieldSize(field) would return
            // non-zero.  Fields (both normal fields and extension fields) will be listed
            // ordered by field number.
            // Use Reflection::GetUnknownFields() or message.unknown_fields() to also get
            // access to fields/extensions unknown to the parser.
            void ListFields(const Message& message, std::vector<const FieldDescriptor*>* output) const;

            // Singular field getters ------------------------------------------
            // These get the value of a non-repeated field.  They return the default
            // value for fields that aren't set.

            int32_t GetInt32(const Message& message, const FieldDescriptor* field) const;
            int64_t GetInt64(const Message& message, const FieldDescriptor* field) const;
            uint32_t GetUInt32(const Message& message, const FieldDescriptor* field) const;
            uint64_t GetUInt64(const Message& message, const FieldDescriptor* field) const;
            float GetFloat(const Message& message, const FieldDescriptor* field) const;
            double GetDouble(const Message& message, const FieldDescriptor* field) const;
            bool GetBool(const Message& message, const FieldDescriptor* field) const;
            std::string GetString(const Message& message, const FieldDescriptor* field) const;
            const EnumValueDescriptor* GetEnum(const Message& message, const FieldDescriptor* field) const;

            // GetEnumValue() returns an enum field's value as an integer rather than
            // an EnumValueDescriptor*. If the integer value does not correspond to a
            // known value descriptor, a new value descriptor is created. (Such a value
            // will only be present when the new unknown-enum-value semantics are enabled
            // for a message.)
            int GetEnumValue(const Message& message, const FieldDescriptor* field) const;

            // See MutableMessage() for the meaning of the "factory" parameter.
            const Message& GetMessage(const Message& message, const FieldDescriptor* field, MessageFactory* factory = nullptr) const;

            // Get a string value without copying, if possible.
            //
            // GetString() necessarily returns a copy of the string.  This can be
            // inefficient when the std::string is already stored in a std::string object
            // in the underlying message.  GetStringReference() will return a reference to
            // the underlying std::string in this case.  Otherwise, it will copy the
            // string into *scratch and return that.
            //
            // Note:  It is perfectly reasonable and useful to write code like:
            //     str = reflection->GetStringReference(message, field, &str);
            //   This line would ensure that only one copy of the string is made
            //   regardless of the field's underlying representation.  When initializing
            //   a newly-constructed string, though, it's just as fast and more
            //   readable to use code like:
            //     std::string str = reflection->GetString(message, field);
            const std::string& GetStringReference(const Message& message, const FieldDescriptor* field, std::string* scratch) const;

            // Singular field mutators -----------------------------------------
            // These mutate the value of a non-repeated field.

            void SetInt32(Message* message, const FieldDescriptor* field, int32_t value) const;
            void SetInt64(Message* message, const FieldDescriptor* field, int64_t value) const;
            void SetUInt32(Message* message, const FieldDescriptor* field, uint32_t value) const;
            void SetUInt64(Message* message, const FieldDescriptor* field, uint64_t value) const;
            void SetFloat(Message* message, const FieldDescriptor* field, float value) const;
            void SetDouble(Message* message, const FieldDescriptor* field, double value) const;
            void SetBool(Message* message, const FieldDescriptor* field, bool value) const;
            void SetString(Message* message, const FieldDescriptor* field, std::string value) const;
            void SetEnum(Message* message, const FieldDescriptor* field, const EnumValueDescriptor* value) const;
            // Set an enum field's value with an integer rather than EnumValueDescriptor.
            // For proto3 this is just setting the enum field to the value specified, for
            // proto2 it's more complicated. If value is a known enum value the field is
            // set as usual. If the value is unknown then it is added to the unknown field
            // set. Note this matches the behavior of parsing unknown enum values.
            // If multiple calls with unknown values happen than they are all added to the
            // unknown field set in order of the calls.
            void SetEnumValue(Message* message, const FieldDescriptor* field, int value) const;

            // Get a mutable pointer to a field with a message type.  If a MessageFactory
            // is provided, it will be used to construct instances of the sub-message;
            // otherwise, the default factory is used.  If the field is an extension that
            // does not live in the same pool as the containing message's descriptor (e.g.
            // it lives in an overlay pool), then a MessageFactory must be provided.
            // If you have no idea what that meant, then you probably don't need to worry
            // about it (don't provide a MessageFactory).  WARNING:  If the
            // FieldDescriptor is for a compiled-in extension, then
            // factory->GetPrototype(field->message_type()) MUST return an instance of
            // the compiled-in class for this type, NOT DynamicMessage.
            Message* MutableMessage(Message* message, const FieldDescriptor* field, MessageFactory* factory = nullptr) const;

            // Replaces the message specified by 'field' with the already-allocated object
            // sub_message, passing ownership to the message.  If the field contained a
            // message, that message is deleted.  If sub_message is nullptr, the field is
            // cleared.
            void SetAllocatedMessage(Message* message, Message* sub_message, const FieldDescriptor* field) const;

            // Similar to `SetAllocatedMessage`, but omits all internal safety and
            // ownership checks.  This method should only be used when the objects are on
            // the same arena or paired with a call to `UnsafeArenaReleaseMessage`.
            void UnsafeArenaSetAllocatedMessage(Message* message, Message* sub_message, const FieldDescriptor* field) const;

            // Releases the message specified by 'field' and returns the pointer,
            // ReleaseMessage() will return the message the message object if it exists.
            // Otherwise, it may or may not return nullptr.  In any case, if the return
            // value is non-null, the caller takes ownership of the pointer.
            // If the field existed (HasField() is true), then the returned pointer will
            // be the same as the pointer returned by MutableMessage().
            // This function has the same effect as ClearField().
            PROTOBUF_NODISCARD Message* ReleaseMessage(
                Message* message, const FieldDescriptor* field, MessageFactory* factory = nullptr
            ) const;

            // Similar to `ReleaseMessage`, but omits all internal safety and ownership
            // checks.  This method should only be used when the objects are on the same
            // arena or paired with a call to `UnsafeArenaSetAllocatedMessage`.
            Message* UnsafeArenaReleaseMessage(Message* message, const FieldDescriptor* field, MessageFactory* factory = nullptr) const;

            // Repeated field getters ------------------------------------------
            // These get the value of one element of a repeated field.

            int32_t GetRepeatedInt32(const Message& message, const FieldDescriptor* field, int index) const;
            int64_t GetRepeatedInt64(const Message& message, const FieldDescriptor* field, int index) const;
            uint32_t GetRepeatedUInt32(const Message& message, const FieldDescriptor* field, int index) const;
            uint64_t GetRepeatedUInt64(const Message& message, const FieldDescriptor* field, int index) const;
            float GetRepeatedFloat(const Message& message, const FieldDescriptor* field, int index) const;
            double GetRepeatedDouble(const Message& message, const FieldDescriptor* field, int index) const;
            bool GetRepeatedBool(const Message& message, const FieldDescriptor* field, int index) const;
            std::string GetRepeatedString(const Message& message, const FieldDescriptor* field, int index) const;
            const EnumValueDescriptor* GetRepeatedEnum(const Message& message, const FieldDescriptor* field, int index) const;
            // GetRepeatedEnumValue() returns an enum field's value as an integer rather
            // than an EnumValueDescriptor*. If the integer value does not correspond to a
            // known value descriptor, a new value descriptor is created. (Such a value
            // will only be present when the new unknown-enum-value semantics are enabled
            // for a message.)
            int GetRepeatedEnumValue(const Message& message, const FieldDescriptor* field, int index) const;
            const Message& GetRepeatedMessage(const Message& message, const FieldDescriptor* field, int index) const;

            // See GetStringReference(), above.
            const std::string& GetRepeatedStringReference(const Message& message, const FieldDescriptor* field, int index, std::string* scratch) const;

            // Repeated field mutators -----------------------------------------
            // These mutate the value of one element of a repeated field.

            void SetRepeatedInt32(Message* message, const FieldDescriptor* field, int index, int32_t value) const;
            void SetRepeatedInt64(Message* message, const FieldDescriptor* field, int index, int64_t value) const;
            void SetRepeatedUInt32(Message* message, const FieldDescriptor* field, int index, uint32_t value) const;
            void SetRepeatedUInt64(Message* message, const FieldDescriptor* field, int index, uint64_t value) const;
            void SetRepeatedFloat(Message* message, const FieldDescriptor* field, int index, float value) const;
            void SetRepeatedDouble(Message* message, const FieldDescriptor* field, int index, double value) const;
            void SetRepeatedBool(Message* message, const FieldDescriptor* field, int index, bool value) const;
            void SetRepeatedString(Message* message, const FieldDescriptor* field, int index, std::string value) const;
            void SetRepeatedEnum(Message* message, const FieldDescriptor* field, int index, const EnumValueDescriptor* value) const;
            // Set an enum field's value with an integer rather than EnumValueDescriptor.
            // For proto3 this is just setting the enum field to the value specified, for
            // proto2 it's more complicated. If value is a known enum value the field is
            // set as usual. If the value is unknown then it is added to the unknown field
            // set. Note this matches the behavior of parsing unknown enum values.
            // If multiple calls with unknown values happen than they are all added to the
            // unknown field set in order of the calls.
            void SetRepeatedEnumValue(Message* message, const FieldDescriptor* field, int index, int value) const;
            // Get a mutable pointer to an element of a repeated field with a message
            // type.
            Message* MutableRepeatedMessage(Message* message, const FieldDescriptor* field, int index) const;

            // Repeated field adders -------------------------------------------
            // These add an element to a repeated field.

            void AddInt32(Message* message, const FieldDescriptor* field, int32_t value) const;
            void AddInt64(Message* message, const FieldDescriptor* field, int64_t value) const;
            void AddUInt32(Message* message, const FieldDescriptor* field, uint32_t value) const;
            void AddUInt64(Message* message, const FieldDescriptor* field, uint64_t value) const;
            void AddFloat(Message* message, const FieldDescriptor* field, float value) const;
            void AddDouble(Message* message, const FieldDescriptor* field, double value) const;
            void AddBool(Message* message, const FieldDescriptor* field, bool value) const;
            void AddString(Message* message, const FieldDescriptor* field, std::string value) const;
            void AddEnum(Message* message, const FieldDescriptor* field, const EnumValueDescriptor* value) const;
            // Add an integer value to a repeated enum field rather than
            // EnumValueDescriptor. For proto3 this is just setting the enum field to the
            // value specified, for proto2 it's more complicated. If value is a known enum
            // value the field is set as usual. If the value is unknown then it is added
            // to the unknown field set. Note this matches the behavior of parsing unknown
            // enum values. If multiple calls with unknown values happen than they are all
            // added to the unknown field set in order of the calls.
            void AddEnumValue(Message* message, const FieldDescriptor* field, int value) const;
            // See MutableMessage() for comments on the "factory" parameter.
            Message* AddMessage(Message* message, const FieldDescriptor* field, MessageFactory* factory = nullptr) const;

            // Appends an already-allocated object 'new_entry' to the repeated field
            // specified by 'field' passing ownership to the message.
            void AddAllocatedMessage(Message* message, const FieldDescriptor* field, Message* new_entry) const;

            // Similar to AddAllocatedMessage() without internal safety and ownership
            // checks. This method should only be used when the objects are on the same
            // arena or paired with a call to `UnsafeArenaReleaseLast`.
            void UnsafeArenaAddAllocatedMessage(Message* message, const FieldDescriptor* field, Message* new_entry) const;

            // Get a RepeatedFieldRef object that can be used to read the underlying
            // repeated field. The type parameter T must be set according to the
            // field's cpp type. The following table shows the mapping from cpp type
            // to acceptable T.
            //
            //   field->cpp_type()      T
            //   CPPTYPE_INT32        int32_t
            //   CPPTYPE_UINT32       uint32_t
            //   CPPTYPE_INT64        int64_t
            //   CPPTYPE_UINT64       uint64_t
            //   CPPTYPE_DOUBLE       double
            //   CPPTYPE_FLOAT        float
            //   CPPTYPE_BOOL         bool
            //   CPPTYPE_ENUM         generated enum type or int32_t
            //   CPPTYPE_STRING       std::string
            //   CPPTYPE_MESSAGE      generated message type or google::protobuf::Message
            //
            // A RepeatedFieldRef object can be copied and the resulted object will point
            // to the same repeated field in the same message. The object can be used as
            // long as the message is not destroyed.
            //
            // Note that to use this method users need to include the header file
            // "reflection.h" (which defines the RepeatedFieldRef class templates).
            template<typename T>
            RepeatedFieldRef<T> GetRepeatedFieldRef(const Message& message, const FieldDescriptor* field) const;

            // Like GetRepeatedFieldRef() but return an object that can also be used
            // manipulate the underlying repeated field.
            template<typename T>
            MutableRepeatedFieldRef<T> GetMutableRepeatedFieldRef(
                Message* message, const FieldDescriptor* field
            ) const;

            // DEPRECATED. Please use Get(Mutable)RepeatedFieldRef() for repeated field
            // access. The following repeated field accessors will be removed in the
            // future.
            //
            // Repeated field accessors  -------------------------------------------------
            // The methods above, e.g. GetRepeatedInt32(msg, fd, index), provide singular
            // access to the data in a RepeatedField.  The methods below provide aggregate
            // access by exposing the RepeatedField object itself with the Message.
            // Applying these templates to inappropriate types will lead to an undefined
            // reference at link time (e.g. GetRepeatedField<***double>), or possibly a
            // template matching error at compile time (e.g. GetRepeatedPtrField<File>).
            //
            // Usage example: my_doubs = refl->GetRepeatedField<double>(msg, fd);

            // DEPRECATED. Please use GetRepeatedFieldRef().
            //
            // for T = Cord and all protobuf scalar types except enums.
            template<typename T>
            PROTOBUF_DEPRECATED_MSG("Please use GetRepeatedFieldRef() instead")
            const RepeatedField<T>& GetRepeatedField(const Message& msg, const FieldDescriptor* d) const
            {
                return GetRepeatedFieldInternal<T>(msg, d);
            }

            // DEPRECATED. Please use GetMutableRepeatedFieldRef().
            //
            // for T = Cord and all protobuf scalar types except enums.
            template<typename T>
            PROTOBUF_DEPRECATED_MSG("Please use GetMutableRepeatedFieldRef() instead")
            RepeatedField<T>* MutableRepeatedField(Message* msg, const FieldDescriptor* d) const
            {
                return MutableRepeatedFieldInternal<T>(msg, d);
            }

            // DEPRECATED. Please use GetRepeatedFieldRef().
            //
            // for T = std::string, google::protobuf::internal::StringPieceField
            //         google::protobuf::Message & descendants.
            template<typename T>
            PROTOBUF_DEPRECATED_MSG("Please use GetRepeatedFieldRef() instead")
            const RepeatedPtrField<T>& GetRepeatedPtrField(
                const Message& msg, const FieldDescriptor* d
            ) const
            {
                return GetRepeatedPtrFieldInternal<T>(msg, d);
            }

            // DEPRECATED. Please use GetMutableRepeatedFieldRef().
            //
            // for T = std::string, google::protobuf::internal::StringPieceField
            //         google::protobuf::Message & descendants.
            template<typename T>
            PROTOBUF_DEPRECATED_MSG("Please use GetMutableRepeatedFieldRef() instead")
            RepeatedPtrField<T>* MutableRepeatedPtrField(Message* msg, const FieldDescriptor* d) const
            {
                return MutableRepeatedPtrFieldInternal<T>(msg, d);
            }

            // Extensions ----------------------------------------------------------------

            // Try to find an extension of this message type by fully-qualified field
            // name.  Returns nullptr if no extension is known for this name or number.
            const FieldDescriptor* FindKnownExtensionByName(
                const std::string& name
            ) const;

            // Try to find an extension of this message type by field number.
            // Returns nullptr if no extension is known for this name or number.
            const FieldDescriptor* FindKnownExtensionByNumber(int number) const;

            // Feature Flags -------------------------------------------------------------

            // Does this message support storing arbitrary integer values in enum fields?
            // If |true|, GetEnumValue/SetEnumValue and associated repeated-field versions
            // take arbitrary integer values, and the legacy GetEnum() getter will
            // dynamically create an EnumValueDescriptor for any integer value without
            // one. If |false|, setting an unknown enum value via the integer-based
            // setters results in undefined behavior (in practice, GOOGLE_DCHECK-fails).
            //
            // Generic code that uses reflection to handle messages with enum fields
            // should check this flag before using the integer-based setter, and either
            // downgrade to a compatible value or use the UnknownFieldSet if not. For
            // example:
            //
            //   int new_value = GetValueFromApplicationLogic();
            //   if (reflection->SupportsUnknownEnumValues()) {
            //     reflection->SetEnumValue(message, field, new_value);
            //   } else {
            //     if (field_descriptor->enum_type()->
            //             FindValueByNumber(new_value) != nullptr) {
            //       reflection->SetEnumValue(message, field, new_value);
            //     } else if (emit_unknown_enum_values) {
            //       reflection->MutableUnknownFields(message)->AddVarint(
            //           field->number(), new_value);
            //     } else {
            //       // convert value to a compatible/default value.
            //       new_value = CompatibleDowngrade(new_value);
            //       reflection->SetEnumValue(message, field, new_value);
            //     }
            //   }
            bool SupportsUnknownEnumValues() const;

            // Returns the MessageFactory associated with this message.  This can be
            // useful for determining if a message is a generated message or not, for
            // example:
            //   if (message->GetReflection()->GetMessageFactory() ==
            //       google::protobuf::MessageFactory::generated_factory()) {
            //     // This is a generated message.
            //   }
            // It can also be used to create more messages of this type, though
            // Message::New() is an easier way to accomplish this.
            MessageFactory* GetMessageFactory() const;

        private:
            template<typename T>
            const RepeatedField<T>& GetRepeatedFieldInternal(
                const Message& message, const FieldDescriptor* field
            ) const;
            template<typename T>
            RepeatedField<T>* MutableRepeatedFieldInternal(
                Message* message, const FieldDescriptor* field
            ) const;
            template<typename T>
            const RepeatedPtrField<T>& GetRepeatedPtrFieldInternal(
                const Message& message, const FieldDescriptor* field
            ) const;
            template<typename T>
            RepeatedPtrField<T>* MutableRepeatedPtrFieldInternal(
                Message* message, const FieldDescriptor* field
            ) const;
            // Obtain a pointer to a Repeated Field Structure and do some type checking:
            //   on field->cpp_type(),
            //   on field->field_option().ctype() (if ctype >= 0)
            //   of field->message_type() (if message_type != nullptr).
            // We use 2 routine rather than 4 (const vs mutable) x (scalar vs pointer).
            void* MutableRawRepeatedField(Message* message, const FieldDescriptor* field, FieldDescriptor::CppType, int ctype, const Descriptor* message_type) const;

            const void* GetRawRepeatedField(const Message& message, const FieldDescriptor* field, FieldDescriptor::CppType cpptype, int ctype, const Descriptor* message_type) const;

            // The following methods are used to implement (Mutable)RepeatedFieldRef.
            // A Ref object will store a raw pointer to the repeated field data (obtained
            // from RepeatedFieldData()) and a pointer to a Accessor (obtained from
            // RepeatedFieldAccessor) which will be used to access the raw data.

            // Returns a raw pointer to the repeated field
            //
            // "cpp_type" and "message_type" are deduced from the type parameter T passed
            // to Get(Mutable)RepeatedFieldRef. If T is a generated message type,
            // "message_type" should be set to its descriptor. Otherwise "message_type"
            // should be set to nullptr. Implementations of this method should check
            // whether "cpp_type"/"message_type" is consistent with the actual type of the
            // field. We use 1 routine rather than 2 (const vs mutable) because it is
            // protected and it doesn't change the message.
            void* RepeatedFieldData(Message* message, const FieldDescriptor* field, FieldDescriptor::CppType cpp_type, const Descriptor* message_type) const;

            // The returned pointer should point to a singleton instance which implements
            // the RepeatedFieldAccessor interface.
            const internal::RepeatedFieldAccessor* RepeatedFieldAccessor(
                const FieldDescriptor* field
            ) const;

            // Lists all fields of the message which are currently set, except for unknown
            // fields and stripped fields. See ListFields for details.
            void ListFieldsOmitStripped(
                const Message& message,
                std::vector<const FieldDescriptor*>* output
            ) const;

            bool IsMessageStripped(const Descriptor* descriptor) const
            {
                return schema_.IsMessageStripped(descriptor);
            }

            friend class TextFormat;

            void ListFieldsMayFailOnStripped(
                const Message& message, bool should_fail, std::vector<const FieldDescriptor*>* output
            ) const;

            // Returns true if the message field is backed by a LazyField.
            //
            // A message field may be backed by a LazyField without the user annotation
            // ([lazy = true]). While the user-annotated LazyField is lazily verified on
            // first touch (i.e. failure on access rather than parsing if the LazyField is
            // not initialized), the inferred LazyField is eagerly verified to avoid lazy
            // parsing error at the cost of lower efficiency. When reflecting a message
            // field, use this API instead of checking field->options().lazy().
            bool IsLazyField(const FieldDescriptor* field) const
            {
                return IsLazilyVerifiedLazyField(field) ||
                       IsEagerlyVerifiedLazyField(field);
            }

            // Returns true if the field is lazy extension. It is meant to allow python
            // reparse lazy field until b/157559327 is fixed.
            bool IsLazyExtension(const Message& message, const FieldDescriptor* field) const;

            bool IsLazilyVerifiedLazyField(const FieldDescriptor* field) const;
            bool IsEagerlyVerifiedLazyField(const FieldDescriptor* field) const;

            friend class FastReflectionMessageMutator;
            friend bool internal::IsDescendant(Message& root, const Message& message);

            const Descriptor* const descriptor_;
            const internal::ReflectionSchema schema_;
            const DescriptorPool* const descriptor_pool_;
            MessageFactory* const message_factory_;

            // Last non weak field index. This is an optimization when most weak fields
            // are at the end of the containing message. If a message proto doesn't
            // contain weak fields, then this field equals descriptor_->field_count().
            int last_non_weak_field_index_;

            template<typename T, typename Enable>
            friend class RepeatedFieldRef;
            template<typename T, typename Enable>
            friend class MutableRepeatedFieldRef;
            friend class ::PROTOBUF_NAMESPACE_ID::MessageLayoutInspector;
            friend class ::PROTOBUF_NAMESPACE_ID::AssignDescriptorsHelper;
            friend class DynamicMessageFactory;
            friend class GeneratedMessageReflectionTestHelper;
            friend class python::MapReflectionFriend;
            friend class python::MessageReflectionFriend;
            friend class util::MessageDifferencer;
#define GOOGLE_PROTOBUF_HAS_CEL_MAP_REFLECTION_FRIEND
            friend class expr::CelMapReflectionFriend;
            friend class internal::MapFieldReflectionTest;
            friend class internal::MapKeySorter;
            friend class internal::WireFormat;
            friend class internal::ReflectionOps;
            friend class internal::SwapFieldHelper;
            // Needed for implementing text format for map.
            friend class internal::MapFieldPrinterHelper;

            Reflection(const Descriptor* descriptor, const internal::ReflectionSchema& schema, const DescriptorPool* pool, MessageFactory* factory);

            // Special version for specialized implementations of string.  We can't
            // call MutableRawRepeatedField directly here because we don't have access to
            // FieldOptions::* which are defined in descriptor.pb.h.  Including that
            // file here is not possible because it would cause a circular include cycle.
            // We use 1 routine rather than 2 (const vs mutable) because it is private
            // and mutable a repeated string field doesn't change the message.
            void* MutableRawRepeatedString(Message* message, const FieldDescriptor* field, bool is_string) const;

            friend class MapReflectionTester;
            // Returns true if key is in map. Returns false if key is not in map field.
            bool ContainsMapKey(const Message& message, const FieldDescriptor* field, const MapKey& key) const;

            // If key is in map field: Saves the value pointer to val and returns
            // false. If key in not in map field: Insert the key into map, saves
            // value pointer to val and returns true. Users are able to modify the
            // map value by MapValueRef.
            bool InsertOrLookupMapValue(Message* message, const FieldDescriptor* field, const MapKey& key, MapValueRef* val) const;

            // If key is in map field: Saves the value pointer to val and returns true.
            // Returns false if key is not in map field. Users are NOT able to modify
            // the value by MapValueConstRef.
            bool LookupMapValue(const Message& message, const FieldDescriptor* field, const MapKey& key, MapValueConstRef* val) const;
            bool LookupMapValue(const Message&, const FieldDescriptor*, const MapKey&, MapValueRef*) const = delete;

            // Delete and returns true if key is in the map field. Returns false
            // otherwise.
            bool DeleteMapValue(Message* message, const FieldDescriptor* field, const MapKey& key) const;

            // Returns a MapIterator referring to the first element in the map field.
            // If the map field is empty, this function returns the same as
            // reflection::MapEnd. Mutation to the field may invalidate the iterator.
            MapIterator MapBegin(Message* message, const FieldDescriptor* field) const;

            // Returns a MapIterator referring to the theoretical element that would
            // follow the last element in the map field. It does not point to any
            // real element. Mutation to the field may invalidate the iterator.
            MapIterator MapEnd(Message* message, const FieldDescriptor* field) const;

            // Get the number of <key, value> pair of a map field. The result may be
            // different from FieldSize which can have duplicate keys.
            int MapSize(const Message& message, const FieldDescriptor* field) const;

            // Help method for MapIterator.
            friend class MapIterator;
            friend class WireFormatForMapFieldTest;
            internal::MapFieldBase* MutableMapData(Message* message, const FieldDescriptor* field) const;

            const internal::MapFieldBase* GetMapData(const Message& message, const FieldDescriptor* field) const;

            template<class T>
            const T& GetRawNonOneof(const Message& message, const FieldDescriptor* field) const;
            template<class T>
            T* MutableRawNonOneof(Message* message, const FieldDescriptor* field) const;

            template<typename Type>
            const Type& GetRaw(const Message& message, const FieldDescriptor* field) const;
            template<typename Type>
            inline Type* MutableRaw(Message* message, const FieldDescriptor* field) const;
            template<typename Type>
            const Type& DefaultRaw(const FieldDescriptor* field) const;

            const Message* GetDefaultMessageInstance(const FieldDescriptor* field) const;

            inline const uint32_t* GetHasBits(const Message& message) const;
            inline uint32_t* MutableHasBits(Message* message) const;
            inline uint32_t GetOneofCase(const Message& message, const OneofDescriptor* oneof_descriptor) const;
            inline uint32_t* MutableOneofCase(
                Message* message, const OneofDescriptor* oneof_descriptor
            ) const;
            inline bool HasExtensionSet(const Message& /* message */) const
            {
                return schema_.HasExtensionSet();
            }
            const internal::ExtensionSet& GetExtensionSet(const Message& message) const;
            internal::ExtensionSet* MutableExtensionSet(Message* message) const;

            const internal::InternalMetadata& GetInternalMetadata(
                const Message& message
            ) const;

            internal::InternalMetadata* MutableInternalMetadata(Message* message) const;

            inline bool IsInlined(const FieldDescriptor* field) const;

            inline bool HasBit(const Message& message, const FieldDescriptor* field) const;
            inline void SetBit(Message* message, const FieldDescriptor* field) const;
            inline void ClearBit(Message* message, const FieldDescriptor* field) const;
            inline void SwapBit(Message* message1, Message* message2, const FieldDescriptor* field) const;

            inline const uint32_t* GetInlinedStringDonatedArray(
                const Message& message
            ) const;
            inline uint32_t* MutableInlinedStringDonatedArray(Message* message) const;
            inline bool IsInlinedStringDonated(const Message& message, const FieldDescriptor* field) const;
            inline void SwapInlinedStringDonated(Message* lhs, Message* rhs, const FieldDescriptor* field) const;

            // Shallow-swap fields listed in fields vector of two messages. It is the
            // caller's responsibility to make sure shallow swap is safe.
            void UnsafeShallowSwapFields(
                Message* message1, Message* message2, const std::vector<const FieldDescriptor*>& fields
            ) const;

            // This function only swaps the field. Should swap corresponding has_bit
            // before or after using this function.
            void SwapField(Message* message1, Message* message2, const FieldDescriptor* field) const;

            // Unsafe but shallow version of SwapField.
            void UnsafeShallowSwapField(Message* message1, Message* message2, const FieldDescriptor* field) const;

            template<bool unsafe_shallow_swap>
            void SwapFieldsImpl(Message* message1, Message* message2, const std::vector<const FieldDescriptor*>& fields) const;

            template<bool unsafe_shallow_swap>
            void SwapOneofField(Message* lhs, Message* rhs, const OneofDescriptor* oneof_descriptor) const;

            inline bool HasOneofField(const Message& message, const FieldDescriptor* field) const;
            inline void SetOneofCase(Message* message, const FieldDescriptor* field) const;
            inline void ClearOneofField(Message* message, const FieldDescriptor* field) const;

            template<typename Type>
            inline const Type& GetField(const Message& message, const FieldDescriptor* field) const;
            template<typename Type>
            inline void SetField(Message* message, const FieldDescriptor* field, const Type& value) const;
            template<typename Type>
            inline Type* MutableField(Message* message, const FieldDescriptor* field) const;
            template<typename Type>
            inline const Type& GetRepeatedField(const Message& message, const FieldDescriptor* field, int index) const;
            template<typename Type>
            inline const Type& GetRepeatedPtrField(const Message& message, const FieldDescriptor* field, int index) const;
            template<typename Type>
            inline void SetRepeatedField(Message* message, const FieldDescriptor* field, int index, Type value) const;
            template<typename Type>
            inline Type* MutableRepeatedField(Message* message, const FieldDescriptor* field, int index) const;
            template<typename Type>
            inline void AddField(Message* message, const FieldDescriptor* field, const Type& value) const;
            template<typename Type>
            inline Type* AddField(Message* message, const FieldDescriptor* field) const;

            int GetExtensionNumberOrDie(const Descriptor* type) const;

            // Internal versions of EnumValue API perform no checking. Called after checks
            // by public methods.
            void SetEnumValueInternal(Message* message, const FieldDescriptor* field, int value) const;
            void SetRepeatedEnumValueInternal(Message* message, const FieldDescriptor* field, int index, int value) const;
            void AddEnumValueInternal(Message* message, const FieldDescriptor* field, int value) const;

            friend inline  // inline so nobody can call this function.
                void
                RegisterAllTypesInternal(const Metadata* file_level_metadata, int size);
            friend inline const char* ParseLenDelim(int field_number, const FieldDescriptor* field, Message* msg, const Reflection* reflection, const char* ptr, internal::ParseContext* ctx);
            friend inline const char* ParsePackedField(const FieldDescriptor* field, Message* msg, const Reflection* reflection, const char* ptr, internal::ParseContext* ctx);

            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reflection);
        };

        // Abstract interface for a factory for message objects.
        class PROTOBUF_EXPORT MessageFactory
        {
        public:
            inline MessageFactory()
            {
            }
            virtual ~MessageFactory();

            // Given a Descriptor, gets or constructs the default (prototype) Message
            // of that type.  You can then call that message's New() method to construct
            // a mutable message of that type.
            //
            // Calling this method twice with the same Descriptor returns the same
            // object.  The returned object remains property of the factory.  Also, any
            // objects created by calling the prototype's New() method share some data
            // with the prototype, so these must be destroyed before the MessageFactory
            // is destroyed.
            //
            // The given descriptor must outlive the returned message, and hence must
            // outlive the MessageFactory.
            //
            // Some implementations do not support all types.  GetPrototype() will
            // return nullptr if the descriptor passed in is not supported.
            //
            // This method may or may not be thread-safe depending on the implementation.
            // Each implementation should document its own degree thread-safety.
            virtual const Message* GetPrototype(const Descriptor* type) = 0;

            // Gets a MessageFactory which supports all generated, compiled-in messages.
            // In other words, for any compiled-in type FooMessage, the following is true:
            //   MessageFactory::generated_factory()->GetPrototype(
            //     FooMessage::descriptor()) == FooMessage::default_instance()
            // This factory supports all types which are found in
            // DescriptorPool::generated_pool().  If given a descriptor from any other
            // pool, GetPrototype() will return nullptr.  (You can also check if a
            // descriptor is for a generated message by checking if
            // descriptor->file()->pool() == DescriptorPool::generated_pool().)
            //
            // This factory is 100% thread-safe; calling GetPrototype() does not modify
            // any shared data.
            //
            // This factory is a singleton.  The caller must not delete the object.
            static MessageFactory* generated_factory();

            // For internal use only:  Registers a .proto file at static initialization
            // time, to be placed in generated_factory.  The first time GetPrototype()
            // is called with a descriptor from this file, |register_messages| will be
            // called, with the file name as the parameter.  It must call
            // InternalRegisterGeneratedMessage() (below) to register each message type
            // in the file.  This strange mechanism is necessary because descriptors are
            // built lazily, so we can't register types by their descriptor until we
            // know that the descriptor exists.  |filename| must be a permanent string.
            static void InternalRegisterGeneratedFile(
                const google::protobuf::internal::DescriptorTable* table
            );

            // For internal use only:  Registers a message type.  Called only by the
            // functions which are registered with InternalRegisterGeneratedFile(),
            // above.
            static void InternalRegisterGeneratedMessage(const Descriptor* descriptor, const Message* prototype);

        private:
            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFactory);
        };

#define DECLARE_GET_REPEATED_FIELD(TYPE)                         \
    template<>                                                   \
    PROTOBUF_EXPORT const RepeatedField<TYPE>&                   \
        Reflection::GetRepeatedFieldInternal<TYPE>(              \
            const Message& message, const FieldDescriptor* field \
        ) const;                                                 \
                                                                 \
    template<>                                                   \
    PROTOBUF_EXPORT RepeatedField<TYPE>*                         \
        Reflection::MutableRepeatedFieldInternal<TYPE>(          \
            Message * message, const FieldDescriptor* field      \
        ) const;

        DECLARE_GET_REPEATED_FIELD(int32_t)
        DECLARE_GET_REPEATED_FIELD(int64_t)
        DECLARE_GET_REPEATED_FIELD(uint32_t)
        DECLARE_GET_REPEATED_FIELD(uint64_t)
        DECLARE_GET_REPEATED_FIELD(float)
        DECLARE_GET_REPEATED_FIELD(double)
        DECLARE_GET_REPEATED_FIELD(bool)

#undef DECLARE_GET_REPEATED_FIELD

        // Tries to downcast this message to a generated message type.  Returns nullptr
        // if this class is not an instance of T.  This works even if RTTI is disabled.
        //
        // This also has the effect of creating a strong reference to T that will
        // prevent the linker from stripping it out at link time.  This can be important
        // if you are using a DynamicMessageFactory that delegates to the generated
        // factory.
        template<typename T>
        const T* DynamicCastToGenerated(const Message* from)
        {
            // Compile-time assert that T is a generated type that has a
            // default_instance() accessor, but avoid actually calling it.
            const T& (*get_default_instance)() = &T::default_instance;
            (void)get_default_instance;

            // Compile-time assert that T is a subclass of google::protobuf::Message.
            const Message* unused = static_cast<T*>(nullptr);
            (void)unused;

#if PROTOBUF_RTTI
            return dynamic_cast<const T*>(from);
#else
            bool ok = from != nullptr &&
                      T::default_instance().GetReflection() == from->GetReflection();
            return ok ? down_cast<const T*>(from) : nullptr;
#endif
        }

        template<typename T>
        T* DynamicCastToGenerated(Message* from)
        {
            const Message* message_const = from;
            return const_cast<T*>(DynamicCastToGenerated<T>(message_const));
        }

        // Call this function to ensure that this message's reflection is linked into
        // the binary:
        //
        //   google::protobuf::LinkMessageReflection<pkg::FooMessage>();
        //
        // This will ensure that the following lookup will succeed:
        //
        //   DescriptorPool::generated_pool()->FindMessageTypeByName("pkg.FooMessage");
        //
        // 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 message, 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 the tightest
        // of loops (on x86-64 it compiles into two "mov" instructions).
        template<typename T>
        void LinkMessageReflection()
        {
            internal::StrongReference(T::default_instance);
        }

        // =============================================================================
        // Implementation details for {Get,Mutable}RawRepeatedPtrField.  We provide
        // specializations for <std::string>, <StringPieceField> and <Message> and
        // handle everything else with the default template which will match any type
        // having a method with signature "static const google::protobuf::Descriptor*
        // descriptor()". Such a type presumably is a descendant of google::protobuf::Message.

        template<>
        inline const RepeatedPtrField<std::string>&
            Reflection::GetRepeatedPtrFieldInternal<std::string>(
                const Message& message, const FieldDescriptor* field
            ) const
        {
            return *static_cast<RepeatedPtrField<std::string>*>(
                MutableRawRepeatedString(const_cast<Message*>(&message), field, true)
            );
        }

        template<>
        inline RepeatedPtrField<std::string>*
            Reflection::MutableRepeatedPtrFieldInternal<std::string>(
                Message* message, const FieldDescriptor* field
            ) const
        {
            return static_cast<RepeatedPtrField<std::string>*>(
                MutableRawRepeatedString(message, field, true)
            );
        }

        // -----

        template<>
        inline const RepeatedPtrField<Message>& Reflection::GetRepeatedPtrFieldInternal(
            const Message& message, const FieldDescriptor* field
        ) const
        {
            return *static_cast<const RepeatedPtrField<Message>*>(GetRawRepeatedField(
                message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, nullptr
            ));
        }

        template<>
        inline RepeatedPtrField<Message>* Reflection::MutableRepeatedPtrFieldInternal(
            Message* message, const FieldDescriptor* field
        ) const
        {
            return static_cast<RepeatedPtrField<Message>*>(MutableRawRepeatedField(
                message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, nullptr
            ));
        }

        template<typename PB>
        inline const RepeatedPtrField<PB>& Reflection::GetRepeatedPtrFieldInternal(
            const Message& message, const FieldDescriptor* field
        ) const
        {
            return *static_cast<const RepeatedPtrField<PB>*>(
                GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, PB::default_instance().GetDescriptor())
            );
        }

        template<typename PB>
        inline RepeatedPtrField<PB>* Reflection::MutableRepeatedPtrFieldInternal(
            Message* message, const FieldDescriptor* field
        ) const
        {
            return static_cast<RepeatedPtrField<PB>*>(
                MutableRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, PB::default_instance().GetDescriptor())
            );
        }

        template<typename Type>
        const Type& Reflection::DefaultRaw(const FieldDescriptor* field) const
        {
            return *reinterpret_cast<const Type*>(schema_.GetFieldDefault(field));
        }

        uint32_t Reflection::GetOneofCase(
            const Message& message, const OneofDescriptor* oneof_descriptor
        ) const
        {
            GOOGLE_DCHECK(!oneof_descriptor->is_synthetic());
            return internal::GetConstRefAtOffset<uint32_t>(
                message, schema_.GetOneofCaseOffset(oneof_descriptor)
            );
        }

        bool Reflection::HasOneofField(const Message& message, const FieldDescriptor* field) const
        {
            return (GetOneofCase(message, field->containing_oneof()) == static_cast<uint32_t>(field->number()));
        }

        template<typename Type>
        const Type& Reflection::GetRaw(const Message& message, const FieldDescriptor* field) const
        {
            GOOGLE_DCHECK(!schema_.InRealOneof(field) || HasOneofField(message, field))
                << "Field = " << field->full_name();
            return internal::GetConstRefAtOffset<Type>(message, schema_.GetFieldOffset(field));
        }
    }  // namespace protobuf
}  // namespace google

#include <google/protobuf/port_undef.inc>

#endif  // GOOGLE_PROTOBUF_MESSAGE_H__