THUAI6/CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.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.
//
// RepeatedField and RepeatedPtrField are used by generated protocol message
// classes to manipulate repeated fields.  These classes are very similar to
// STL's vector, but include a number of optimizations found to be useful
// specifically in the case of Protocol Buffers.  RepeatedPtrField is
// particularly different from STL vector as it manages ownership of the
// pointers that it contains.
//
// This header covers RepeatedPtrField.

// IWYU pragma: private, include "net/proto2/public/repeated_field.h"

#ifndef GOOGLE_PROTOBUF_REPEATED_PTR_FIELD_H__
#define GOOGLE_PROTOBUF_REPEATED_PTR_FIELD_H__

#include <utility>

#ifdef _MSC_VER
// This is required for min/max on VS2013 only.
#include <algorithm>
#endif

#include <iterator>
#include <limits>
#include <string>
#include <type_traits>

#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/port.h>
#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
    {

        class Message;
        class Reflection;

        template<typename T>
        struct WeakRepeatedPtrField;

        namespace internal
        {

            class MergePartialFromCodedStreamHelper;
            class SwapFieldHelper;

        }  // namespace internal

        namespace internal
        {
            template<typename It>
            class RepeatedPtrIterator;
            template<typename It, typename VoidPtr>
            class RepeatedPtrOverPtrsIterator;
        }  // namespace internal

        namespace internal
        {

            // type-traits helper for RepeatedPtrFieldBase: we only want to invoke
            // arena-related "copy if on different arena" behavior if the necessary methods
            // exist on the contained type. In particular, we rely on MergeFrom() existing
            // as a general proxy for the fact that a copy will work, and we also provide a
            // specific override for std::string*.
            template<typename T>
            struct TypeImplementsMergeBehaviorProbeForMergeFrom
            {
                typedef char HasMerge;
                typedef long HasNoMerge;

                // We accept either of:
                // - void MergeFrom(const T& other)
                // - bool MergeFrom(const T& other)
                //
                // We mangle these names a bit to avoid compatibility issues in 'unclean'
                // include environments that may have, e.g., "#define test ..." (yes, this
                // exists).
                template<typename U, typename RetType, RetType (U::*)(const U& arg)>
                struct CheckType;
                template<typename U>
                static HasMerge Check(CheckType<U, void, &U::MergeFrom>*);
                template<typename U>
                static HasMerge Check(CheckType<U, bool, &U::MergeFrom>*);
                template<typename U>
                static HasNoMerge Check(...);

                // Resolves to either std::true_type or std::false_type.
                typedef std::integral_constant<bool, (sizeof(Check<T>(0)) == sizeof(HasMerge))>
                    type;
            };

            template<typename T, typename = void>
            struct TypeImplementsMergeBehavior : TypeImplementsMergeBehaviorProbeForMergeFrom<T>
            {
            };

            template<>
            struct TypeImplementsMergeBehavior<std::string>
            {
                typedef std::true_type type;
            };

            template<typename T>
            struct IsMovable : std::integral_constant<bool, std::is_move_constructible<T>::value && std::is_move_assignable<T>::value>
            {
            };

            // This is the common base class for RepeatedPtrFields.  It deals only in void*
            // pointers.  Users should not use this interface directly.
            //
            // The methods of this interface correspond to the methods of RepeatedPtrField,
            // but may have a template argument called TypeHandler.  Its signature is:
            //   class TypeHandler {
            //    public:
            //     typedef MyType Type;
            //     static Type* New();
            //     static Type* NewFromPrototype(const Type* prototype,
            //                                       Arena* arena);
            //     static void Delete(Type*);
            //     static void Clear(Type*);
            //     static void Merge(const Type& from, Type* to);
            //
            //     // Only needs to be implemented if SpaceUsedExcludingSelf() is called.
            //     static int SpaceUsedLong(const Type&);
            //   };
            class PROTOBUF_EXPORT RepeatedPtrFieldBase
            {
            protected:
                constexpr RepeatedPtrFieldBase() :
                    arena_(nullptr),
                    current_size_(0),
                    total_size_(0),
                    rep_(nullptr)
                {
                }
                explicit RepeatedPtrFieldBase(Arena* arena) :
                    arena_(arena),
                    current_size_(0),
                    total_size_(0),
                    rep_(nullptr)
                {
                }

                RepeatedPtrFieldBase(const RepeatedPtrFieldBase&) = delete;
                RepeatedPtrFieldBase& operator=(const RepeatedPtrFieldBase&) = delete;

                ~RepeatedPtrFieldBase()
                {
#ifndef NDEBUG
                    // Try to trigger segfault / asan failure in non-opt builds. If arena_
                    // lifetime has ended before the destructor.
                    if (arena_)
                        (void)arena_->SpaceAllocated();
#endif
                }

                bool empty() const
                {
                    return current_size_ == 0;
                }
                int size() const
                {
                    return current_size_;
                }
                int Capacity() const
                {
                    return total_size_;
                }

                template<typename TypeHandler>
                const typename TypeHandler::Type& at(int index) const
                {
                    GOOGLE_CHECK_GE(index, 0);
                    GOOGLE_CHECK_LT(index, current_size_);
                    return *cast<TypeHandler>(rep_->elements[index]);
                }

                template<typename TypeHandler>
                typename TypeHandler::Type& at(int index)
                {
                    GOOGLE_CHECK_GE(index, 0);
                    GOOGLE_CHECK_LT(index, current_size_);
                    return *cast<TypeHandler>(rep_->elements[index]);
                }

                template<typename TypeHandler>
                typename TypeHandler::Type* Mutable(int index)
                {
                    GOOGLE_DCHECK_GE(index, 0);
                    GOOGLE_DCHECK_LT(index, current_size_);
                    return cast<TypeHandler>(rep_->elements[index]);
                }

                template<typename TypeHandler>
                typename TypeHandler::Type* Add(
                    const typename TypeHandler::Type* prototype = nullptr
                )
                {
                    if (rep_ != nullptr && current_size_ < rep_->allocated_size)
                    {
                        return cast<TypeHandler>(rep_->elements[current_size_++]);
                    }
                    typename TypeHandler::Type* result =
                        TypeHandler::NewFromPrototype(prototype, arena_);
                    return reinterpret_cast<typename TypeHandler::Type*>(
                        AddOutOfLineHelper(result)
                    );
                }

                template<
                    typename TypeHandler,
                    typename std::enable_if<TypeHandler::Movable::value>::type* = nullptr>
                inline void Add(typename TypeHandler::Type&& value)
                {
                    if (rep_ != nullptr && current_size_ < rep_->allocated_size)
                    {
                        *cast<TypeHandler>(rep_->elements[current_size_++]) = std::move(value);
                        return;
                    }
                    if (!rep_ || rep_->allocated_size == total_size_)
                    {
                        Reserve(total_size_ + 1);
                    }
                    ++rep_->allocated_size;
                    typename TypeHandler::Type* result =
                        TypeHandler::New(arena_, std::move(value));
                    rep_->elements[current_size_++] = result;
                }

                template<typename TypeHandler>
                void Delete(int index)
                {
                    GOOGLE_DCHECK_GE(index, 0);
                    GOOGLE_DCHECK_LT(index, current_size_);
                    TypeHandler::Delete(cast<TypeHandler>(rep_->elements[index]), arena_);
                }

                // Must be called from destructor.
                template<typename TypeHandler>
                void Destroy()
                {
                    if (rep_ != nullptr && arena_ == nullptr)
                    {
                        int n = rep_->allocated_size;
                        void* const* elements = rep_->elements;
                        for (int i = 0; i < n; i++)
                        {
                            TypeHandler::Delete(cast<TypeHandler>(elements[i]), nullptr);
                        }
                        const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
                        internal::SizedDelete(rep_, size);
                    }
                    rep_ = nullptr;
                }

                bool NeedsDestroy() const
                {
                    return rep_ != nullptr && arena_ == nullptr;
                }
                void DestroyProtos();  // implemented in the cc file

            public:
                // The next few methods are public so that they can be called from generated
                // code when implicit weak fields are used, but they should never be called by
                // application code.

                template<typename TypeHandler>
                const typename TypeHandler::Type& Get(int index) const
                {
                    GOOGLE_DCHECK_GE(index, 0);
                    GOOGLE_DCHECK_LT(index, current_size_);
                    return *cast<TypeHandler>(rep_->elements[index]);
                }

                // Creates and adds an element using the given prototype, without introducing
                // a link-time dependency on the concrete message type. This method is used to
                // implement implicit weak fields. The prototype may be nullptr, in which case
                // an ImplicitWeakMessage will be used as a placeholder.
                MessageLite* AddWeak(const MessageLite* prototype);

                template<typename TypeHandler>
                void Clear()
                {
                    const int n = current_size_;
                    GOOGLE_DCHECK_GE(n, 0);
                    if (n > 0)
                    {
                        void* const* elements = rep_->elements;
                        int i = 0;
                        do
                        {
                            TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
                        } while (i < n);
                        current_size_ = 0;
                    }
                }

                template<typename TypeHandler>
                void MergeFrom(const RepeatedPtrFieldBase& other)
                {
                    // To avoid unnecessary code duplication and reduce binary size, we use a
                    // layered approach to implementing MergeFrom(). The toplevel method is
                    // templated, so we get a small thunk per concrete message type in the
                    // binary. This calls a shared implementation with most of the logic,
                    // passing a function pointer to another type-specific piece of code that
                    // calls the object-allocate and merge handlers.
                    GOOGLE_DCHECK_NE(&other, this);
                    if (other.current_size_ == 0)
                        return;
                    MergeFromInternal(other, &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
                }

                inline void InternalSwap(RepeatedPtrFieldBase* rhs)
                {
                    GOOGLE_DCHECK(this != rhs);

                    // Swap all fields at once.
                    auto temp = std::make_tuple(rhs->arena_, rhs->current_size_, rhs->total_size_, rhs->rep_);
                    std::tie(rhs->arena_, rhs->current_size_, rhs->total_size_, rhs->rep_) =
                        std::make_tuple(arena_, current_size_, total_size_, rep_);
                    std::tie(arena_, current_size_, total_size_, rep_) = temp;
                }

            protected:
                template<typename TypeHandler>
                void RemoveLast()
                {
                    GOOGLE_DCHECK_GT(current_size_, 0);
                    TypeHandler::Clear(cast<TypeHandler>(rep_->elements[--current_size_]));
                }

                template<typename TypeHandler>
                void CopyFrom(const RepeatedPtrFieldBase& other)
                {
                    if (&other == this)
                        return;
                    RepeatedPtrFieldBase::Clear<TypeHandler>();
                    RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
                }

                void CloseGap(int start, int num);  // implemented in the cc file

                void Reserve(int new_size);  // implemented in the cc file

                template<typename TypeHandler>
                static inline typename TypeHandler::Type* copy(
                    typename TypeHandler::Type* value
                )
                {
                    auto* new_value = TypeHandler::NewFromPrototype(value, nullptr);
                    TypeHandler::Merge(*value, new_value);
                    return new_value;
                }

                // Used for constructing iterators.
                void* const* raw_data() const
                {
                    return rep_ ? rep_->elements : nullptr;
                }
                void** raw_mutable_data() const
                {
                    return rep_ ? const_cast<void**>(rep_->elements) : nullptr;
                }

                template<typename TypeHandler>
                typename TypeHandler::Type** mutable_data()
                {
                    // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
                    //   method entirely.
                    return reinterpret_cast<typename TypeHandler::Type**>(raw_mutable_data());
                }

                template<typename TypeHandler>
                const typename TypeHandler::Type* const* data() const
                {
                    // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
                    //   method entirely.
                    return reinterpret_cast<const typename TypeHandler::Type* const*>(
                        raw_data()
                    );
                }

                template<typename TypeHandler>
                PROTOBUF_NDEBUG_INLINE void Swap(RepeatedPtrFieldBase* other)
                {
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
                    if (GetOwningArena() != nullptr &&
                        GetOwningArena() == other->GetOwningArena())
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
                    if (GetOwningArena() == other->GetOwningArena())
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
                    {
                        InternalSwap(other);
                    }
                    else
                    {
                        SwapFallback<TypeHandler>(other);
                    }
                }

                void SwapElements(int index1, int index2)
                {
                    using std::swap;  // enable ADL with fallback
                    swap(rep_->elements[index1], rep_->elements[index2]);
                }

                template<typename TypeHandler>
                size_t SpaceUsedExcludingSelfLong() const
                {
                    size_t allocated_bytes = static_cast<size_t>(total_size_) * sizeof(void*);
                    if (rep_ != nullptr)
                    {
                        for (int i = 0; i < rep_->allocated_size; ++i)
                        {
                            allocated_bytes +=
                                TypeHandler::SpaceUsedLong(*cast<TypeHandler>(rep_->elements[i]));
                        }
                        allocated_bytes += kRepHeaderSize;
                    }
                    return allocated_bytes;
                }

                // Advanced memory management --------------------------------------

                // Like Add(), but if there are no cleared objects to use, returns nullptr.
                template<typename TypeHandler>
                typename TypeHandler::Type* AddFromCleared()
                {
                    if (rep_ != nullptr && current_size_ < rep_->allocated_size)
                    {
                        return cast<TypeHandler>(rep_->elements[current_size_++]);
                    }
                    else
                    {
                        return nullptr;
                    }
                }

                template<typename TypeHandler>
                void AddAllocated(typename TypeHandler::Type* value)
                {
                    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
                    AddAllocatedInternal<TypeHandler>(value, t);
                }

                template<typename TypeHandler>
                void UnsafeArenaAddAllocated(typename TypeHandler::Type* value)
                {
                    // Make room for the new pointer.
                    if (!rep_ || current_size_ == total_size_)
                    {
                        // The array is completely full with no cleared objects, so grow it.
                        Reserve(total_size_ + 1);
                        ++rep_->allocated_size;
                    }
                    else if (rep_->allocated_size == total_size_)
                    {
                        // There is no more space in the pointer array because it contains some
                        // cleared objects awaiting reuse.  We don't want to grow the array in
                        // this case because otherwise a loop calling AddAllocated() followed by
                        // Clear() would leak memory.
                        TypeHandler::Delete(cast<TypeHandler>(rep_->elements[current_size_]), arena_);
                    }
                    else if (current_size_ < rep_->allocated_size)
                    {
                        // We have some cleared objects.  We don't care about their order, so we
                        // can just move the first one to the end to make space.
                        rep_->elements[rep_->allocated_size] = rep_->elements[current_size_];
                        ++rep_->allocated_size;
                    }
                    else
                    {
                        // There are no cleared objects.
                        ++rep_->allocated_size;
                    }

                    rep_->elements[current_size_++] = value;
                }

                template<typename TypeHandler>
                PROTOBUF_NODISCARD typename TypeHandler::Type* ReleaseLast()
                {
                    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
                    return ReleaseLastInternal<TypeHandler>(t);
                }

                // Releases and returns the last element, but does not do out-of-arena copy.
                // Instead, just returns the raw pointer to the contained element in the
                // arena.
                template<typename TypeHandler>
                typename TypeHandler::Type* UnsafeArenaReleaseLast()
                {
                    GOOGLE_DCHECK_GT(current_size_, 0);
                    typename TypeHandler::Type* result =
                        cast<TypeHandler>(rep_->elements[--current_size_]);
                    --rep_->allocated_size;
                    if (current_size_ < rep_->allocated_size)
                    {
                        // There are cleared elements on the end; replace the removed element
                        // with the last allocated element.
                        rep_->elements[current_size_] = rep_->elements[rep_->allocated_size];
                    }
                    return result;
                }

                int ClearedCount() const
                {
                    return rep_ ? (rep_->allocated_size - current_size_) : 0;
                }

                template<typename TypeHandler>
                void AddCleared(typename TypeHandler::Type* value)
                {
                    GOOGLE_DCHECK(GetOwningArena() == nullptr) << "AddCleared() can only be used on a "
                                                                  "RepeatedPtrField not on an arena.";
                    GOOGLE_DCHECK(TypeHandler::GetOwningArena(value) == nullptr)
                        << "AddCleared() can only accept values not on an arena.";
                    if (!rep_ || rep_->allocated_size == total_size_)
                    {
                        Reserve(total_size_ + 1);
                    }
                    rep_->elements[rep_->allocated_size++] = value;
                }

                template<typename TypeHandler>
                PROTOBUF_NODISCARD typename TypeHandler::Type* ReleaseCleared()
                {
                    GOOGLE_DCHECK(GetOwningArena() == nullptr)
                        << "ReleaseCleared() can only be used on a RepeatedPtrField not on "
                        << "an arena.";
                    GOOGLE_DCHECK(GetOwningArena() == nullptr);
                    GOOGLE_DCHECK(rep_ != nullptr);
                    GOOGLE_DCHECK_GT(rep_->allocated_size, current_size_);
                    return cast<TypeHandler>(rep_->elements[--rep_->allocated_size]);
                }

                template<typename TypeHandler>
                void AddAllocatedInternal(typename TypeHandler::Type* value, std::true_type)
                {
                    // AddAllocated version that implements arena-safe copying behavior.
                    Arena* element_arena =
                        reinterpret_cast<Arena*>(TypeHandler::GetOwningArena(value));
                    Arena* arena = GetOwningArena();
                    if (arena == element_arena && rep_ && rep_->allocated_size < total_size_)
                    {
                        // Fast path: underlying arena representation (tagged pointer) is equal to
                        // our arena pointer, and we can add to array without resizing it (at
                        // least one slot that is not allocated).
                        void** elems = rep_->elements;
                        if (current_size_ < rep_->allocated_size)
                        {
                            // Make space at [current] by moving first allocated element to end of
                            // allocated list.
                            elems[rep_->allocated_size] = elems[current_size_];
                        }
                        elems[current_size_] = value;
                        current_size_ = current_size_ + 1;
                        rep_->allocated_size = rep_->allocated_size + 1;
                    }
                    else
                    {
                        AddAllocatedSlowWithCopy<TypeHandler>(value, element_arena, arena);
                    }
                }

                template<typename TypeHandler>
                void AddAllocatedInternal(
                    // AddAllocated version that does not implement arena-safe copying
                    // behavior.
                    typename TypeHandler::Type* value,
                    std::false_type
                )
                {
                    if (rep_ && rep_->allocated_size < total_size_)
                    {
                        // Fast path: underlying arena representation (tagged pointer) is equal to
                        // our arena pointer, and we can add to array without resizing it (at
                        // least one slot that is not allocated).
                        void** elems = rep_->elements;
                        if (current_size_ < rep_->allocated_size)
                        {
                            // Make space at [current] by moving first allocated element to end of
                            // allocated list.
                            elems[rep_->allocated_size] = elems[current_size_];
                        }
                        elems[current_size_] = value;
                        current_size_ = current_size_ + 1;
                        ++rep_->allocated_size;
                    }
                    else
                    {
                        UnsafeArenaAddAllocated<TypeHandler>(value);
                    }
                }

                // Slowpath handles all cases, copying if necessary.
                template<typename TypeHandler>
                PROTOBUF_NOINLINE void AddAllocatedSlowWithCopy(
                    // Pass value_arena and my_arena to avoid duplicate virtual call (value)
                    // or load (mine).
                    typename TypeHandler::Type* value,
                    Arena* value_arena,
                    Arena* my_arena
                )
                {
                    // Ensure that either the value is in the same arena, or if not, we do the
                    // appropriate thing: Own() it (if it's on heap and we're in an arena) or
                    // copy it to our arena/heap (otherwise).
                    if (my_arena != nullptr && value_arena == nullptr)
                    {
                        my_arena->Own(value);
                    }
                    else if (my_arena != value_arena)
                    {
                        typename TypeHandler::Type* new_value =
                            TypeHandler::NewFromPrototype(value, my_arena);
                        TypeHandler::Merge(*value, new_value);
                        TypeHandler::Delete(value, value_arena);
                        value = new_value;
                    }

                    UnsafeArenaAddAllocated<TypeHandler>(value);
                }

                template<typename TypeHandler>
                typename TypeHandler::Type* ReleaseLastInternal(std::true_type)
                {
                    // ReleaseLast() for types that implement merge/copy behavior.
                    // First, release an element.
                    typename TypeHandler::Type* result = UnsafeArenaReleaseLast<TypeHandler>();
                    // Now perform a copy if we're on an arena.
                    Arena* arena = GetOwningArena();

                    typename TypeHandler::Type* new_result;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
                    new_result = copy<TypeHandler>(result);
                    if (arena == nullptr)
                        delete result;
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
                    new_result = (arena == nullptr) ? result : copy<TypeHandler>(result);
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
                    return new_result;
                }

                template<typename TypeHandler>
                typename TypeHandler::Type* ReleaseLastInternal(std::false_type)
                {
                    // ReleaseLast() for types that *do not* implement merge/copy behavior --
                    // this is the same as UnsafeArenaReleaseLast(). Note that we GOOGLE_DCHECK-fail if
                    // we're on an arena, since the user really should implement the copy
                    // operation in this case.
                    GOOGLE_DCHECK(GetOwningArena() == nullptr)
                        << "ReleaseLast() called on a RepeatedPtrField that is on an arena, "
                        << "with a type that does not implement MergeFrom. This is unsafe; "
                        << "please implement MergeFrom for your type.";
                    return UnsafeArenaReleaseLast<TypeHandler>();
                }

                template<typename TypeHandler>
                PROTOBUF_NOINLINE void SwapFallback(RepeatedPtrFieldBase* other)
                {
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
                    GOOGLE_DCHECK(GetOwningArena() == nullptr || other->GetOwningArena() != GetOwningArena());
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
                    GOOGLE_DCHECK(other->GetOwningArena() != GetOwningArena());
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP

                    // Copy semantics in this case. We try to improve efficiency by placing the
                    // temporary on |other|'s arena so that messages are copied twice rather
                    // than three times.
                    RepeatedPtrFieldBase temp(other->GetOwningArena());
                    temp.MergeFrom<TypeHandler>(*this);
                    this->Clear<TypeHandler>();
                    this->MergeFrom<TypeHandler>(*other);
                    other->InternalSwap(&temp);
                    temp.Destroy<TypeHandler>();  // Frees rep_ if `other` had no arena.
                }

                inline Arena* GetArena() const
                {
                    return arena_;
                }

            protected:
                inline Arena* GetOwningArena() const
                {
                    return arena_;
                }

            private:
                template<typename T>
                friend class Arena::InternalHelper;

                static constexpr int kInitialSize = 0;
                // A few notes on internal representation:
                //
                // We use an indirected approach, with struct Rep, to keep
                // sizeof(RepeatedPtrFieldBase) equivalent to what it was before arena support
                // was added; namely, 3 8-byte machine words on x86-64. An instance of Rep is
                // allocated only when the repeated field is non-empty, and it is a
                // dynamically-sized struct (the header is directly followed by elements[]).
                // We place arena_ and current_size_ directly in the object to avoid cache
                // misses due to the indirection, because these fields are checked frequently.
                // Placing all fields directly in the RepeatedPtrFieldBase instance would cost
                // significant performance for memory-sensitive workloads.
                Arena* arena_;
                int current_size_;
                int total_size_;
                struct Rep
                {
                    int allocated_size;
                    // Here we declare a huge array as a way of approximating C's "flexible
                    // array member" feature without relying on undefined behavior.
                    void* elements[(std::numeric_limits<int>::max() - 2 * sizeof(int)) / sizeof(void*)];
                };
                static constexpr size_t kRepHeaderSize = offsetof(Rep, elements);
                Rep* rep_;

                template<typename TypeHandler>
                static inline typename TypeHandler::Type* cast(void* element)
                {
                    return reinterpret_cast<typename TypeHandler::Type*>(element);
                }
                template<typename TypeHandler>
                static inline const typename TypeHandler::Type* cast(const void* element)
                {
                    return reinterpret_cast<const typename TypeHandler::Type*>(element);
                }

                // Non-templated inner function to avoid code duplication. Takes a function
                // pointer to the type-specific (templated) inner allocate/merge loop.
                void MergeFromInternal(const RepeatedPtrFieldBase& other, void (RepeatedPtrFieldBase::*inner_loop)(void**, void**, int, int))
                {
                    // Note: wrapper has already guaranteed that other.rep_ != nullptr here.
                    int other_size = other.current_size_;
                    void** other_elements = other.rep_->elements;
                    void** new_elements = InternalExtend(other_size);
                    int allocated_elems = rep_->allocated_size - current_size_;
                    (this->*inner_loop)(new_elements, other_elements, other_size, allocated_elems);
                    current_size_ += other_size;
                    if (rep_->allocated_size < current_size_)
                    {
                        rep_->allocated_size = current_size_;
                    }
                }

                // Merges other_elems to our_elems.
                template<typename TypeHandler>
                PROTOBUF_NOINLINE void MergeFromInnerLoop(void** our_elems, void** other_elems, int length, int already_allocated)
                {
                    if (already_allocated < length)
                    {
                        Arena* arena = GetOwningArena();
                        typename TypeHandler::Type* elem_prototype =
                            reinterpret_cast<typename TypeHandler::Type*>(other_elems[0]);
                        for (int i = already_allocated; i < length; i++)
                        {
                            // Allocate a new empty element that we'll merge into below
                            typename TypeHandler::Type* new_elem =
                                TypeHandler::NewFromPrototype(elem_prototype, arena);
                            our_elems[i] = new_elem;
                        }
                    }
                    // Main loop that does the actual merging
                    for (int i = 0; i < length; i++)
                    {
                        // Already allocated: use existing element.
                        typename TypeHandler::Type* other_elem =
                            reinterpret_cast<typename TypeHandler::Type*>(other_elems[i]);
                        typename TypeHandler::Type* new_elem =
                            reinterpret_cast<typename TypeHandler::Type*>(our_elems[i]);
                        TypeHandler::Merge(*other_elem, new_elem);
                    }
                }

                // Internal helper: extends array space if necessary to contain
                // |extend_amount| more elements, and returns a pointer to the element
                // immediately following the old list of elements.  This interface factors out
                // common behavior from Reserve() and MergeFrom() to reduce code size.
                // |extend_amount| must be > 0.
                void** InternalExtend(int extend_amount);

                // Internal helper for Add: adds "obj" as the next element in the
                // array, including potentially resizing the array with Reserve if
                // needed
                void* AddOutOfLineHelper(void* obj);

                // The reflection implementation needs to call protected methods directly,
                // reinterpreting pointers as being to Message instead of a specific Message
                // subclass.
                friend class ::PROTOBUF_NAMESPACE_ID::Reflection;
                friend class ::PROTOBUF_NAMESPACE_ID::internal::SwapFieldHelper;

                // ExtensionSet stores repeated message extensions as
                // RepeatedPtrField<MessageLite>, but non-lite ExtensionSets need to implement
                // SpaceUsedLong(), and thus need to call SpaceUsedExcludingSelfLong()
                // reinterpreting MessageLite as Message.  ExtensionSet also needs to make use
                // of AddFromCleared(), which is not part of the public interface.
                friend class ExtensionSet;

                // The MapFieldBase implementation needs to call protected methods directly,
                // reinterpreting pointers as being to Message instead of a specific Message
                // subclass.
                friend class MapFieldBase;
                friend class MapFieldBaseStub;

                // The table-driven MergePartialFromCodedStream implementation needs to
                // operate on RepeatedPtrField<MessageLite>.
                friend class MergePartialFromCodedStreamHelper;
                friend class AccessorHelper;
                template<typename T>
                friend struct google::protobuf::WeakRepeatedPtrField;
                friend class internal::TcParser;  // TODO(jorg): Remove this friend.
            };

            template<typename GenericType>
            class GenericTypeHandler
            {
            public:
                typedef GenericType Type;
                using Movable = IsMovable<GenericType>;

                static inline GenericType* New(Arena* arena)
                {
                    return Arena::CreateMaybeMessage<Type>(arena);
                }
                static inline GenericType* New(Arena* arena, GenericType&& value)
                {
                    return Arena::Create<GenericType>(arena, std::move(value));
                }
                static inline GenericType* NewFromPrototype(const GenericType* /*prototype*/, Arena* arena = nullptr)
                {
                    return New(arena);
                }
                static inline void Delete(GenericType* value, Arena* arena)
                {
                    if (arena == nullptr)
                    {
                        delete value;
                    }
                }
                static inline Arena* GetOwningArena(GenericType* value)
                {
                    return Arena::GetOwningArena<Type>(value);
                }

                static inline void Clear(GenericType* value)
                {
                    value->Clear();
                }
                static void Merge(const GenericType& from, GenericType* to);
                static inline size_t SpaceUsedLong(const GenericType& value)
                {
                    return value.SpaceUsedLong();
                }
            };

            // NewFromPrototypeHelper() is not defined inline here, as we will need to do a
            // virtual function dispatch anyways to go from Message* to call New/Merge. (The
            // additional helper is needed as a workaround for MSVC.)
            MessageLite* NewFromPrototypeHelper(const MessageLite* prototype, Arena* arena);

            template<>
            inline MessageLite* GenericTypeHandler<MessageLite>::NewFromPrototype(
                const MessageLite* prototype, Arena* arena
            )
            {
                return NewFromPrototypeHelper(prototype, arena);
            }
            template<>
            inline Arena* GenericTypeHandler<MessageLite>::GetOwningArena(
                MessageLite* value
            )
            {
                return value->GetOwningArena();
            }

            template<typename GenericType>
            PROTOBUF_NOINLINE inline void GenericTypeHandler<GenericType>::Merge(
                const GenericType& from, GenericType* to
            )
            {
                to->MergeFrom(from);
            }
            template<>
            void GenericTypeHandler<MessageLite>::Merge(const MessageLite& from, MessageLite* to);

            template<>
            inline void GenericTypeHandler<std::string>::Clear(std::string* value)
            {
                value->clear();
            }
            template<>
            void GenericTypeHandler<std::string>::Merge(const std::string& from, std::string* to);

            // Message specialization bodies defined in message.cc. This split is necessary
            // to allow proto2-lite (which includes this header) to be independent of
            // Message.
            template<>
            PROTOBUF_EXPORT Message* GenericTypeHandler<Message>::NewFromPrototype(
                const Message* prototype, Arena* arena
            );
            template<>
            PROTOBUF_EXPORT Arena* GenericTypeHandler<Message>::GetOwningArena(
                Message* value
            );

            class StringTypeHandler
            {
            public:
                typedef std::string Type;
                using Movable = IsMovable<Type>;

                static inline std::string* New(Arena* arena)
                {
                    return Arena::Create<std::string>(arena);
                }
                static inline std::string* New(Arena* arena, std::string&& value)
                {
                    return Arena::Create<std::string>(arena, std::move(value));
                }
                static inline std::string* NewFromPrototype(const std::string*, Arena* arena)
                {
                    return New(arena);
                }
                static inline Arena* GetOwningArena(std::string*)
                {
                    return nullptr;
                }
                static inline void Delete(std::string* value, Arena* arena)
                {
                    if (arena == nullptr)
                    {
                        delete value;
                    }
                }
                static inline void Clear(std::string* value)
                {
                    value->clear();
                }
                static inline void Merge(const std::string& from, std::string* to)
                {
                    *to = from;
                }
                static size_t SpaceUsedLong(const std::string& value)
                {
                    return sizeof(value) + StringSpaceUsedExcludingSelfLong(value);
                }
            };

        }  // namespace internal

        // RepeatedPtrField is like RepeatedField, but used for repeated strings or
        // Messages.
        template<typename Element>
        class RepeatedPtrField final : private internal::RepeatedPtrFieldBase
        {
        public:
            constexpr RepeatedPtrField();
            explicit RepeatedPtrField(Arena* arena);

            RepeatedPtrField(const RepeatedPtrField& other);

            template<typename Iter, typename = typename std::enable_if<std::is_constructible<Element, decltype(*std::declval<Iter>())>::value>::type>
            RepeatedPtrField(Iter begin, Iter end);

            ~RepeatedPtrField();

            RepeatedPtrField& operator=(const RepeatedPtrField& other);

            RepeatedPtrField(RepeatedPtrField&& other) noexcept;
            RepeatedPtrField& operator=(RepeatedPtrField&& other) noexcept;

            bool empty() const;
            int size() const;

            const Element& Get(int index) const;
            Element* Mutable(int index);

            // Unlike std::vector, adding an element to a RepeatedPtrField doesn't always
            // make a new element; it might re-use an element left over from when the
            // field was Clear()'d or reize()'d smaller.  For this reason, Add() is the
            // fastest API for adding a new element.
            Element* Add();

            // `Add(std::move(value));` is equivalent to `*Add() = std::move(value);`
            // It will either move-construct to the end of this field, or swap value
            // with the new-or-recycled element at the end of this field.  Note that
            // this operation is very slow if this RepeatedPtrField is not on the
            // same Arena, if any, as `value`.
            void Add(Element&& value);

            // Copying to the end of this RepeatedPtrField is slowest of all; it can't
            // reliably copy-construct to the last element of this RepeatedPtrField, for
            // example (unlike std::vector).
            // We currently block this API.  The right way to add to the end is to call
            // Add() and modify the element it points to.
            // If you must add an existing value, call `*Add() = value;`
            void Add(const Element& value) = delete;

            // Append elements in the range [begin, end) after reserving
            // the appropriate number of elements.
            template<typename Iter>
            void Add(Iter begin, Iter end);

            const Element& operator[](int index) const
            {
                return Get(index);
            }
            Element& operator[](int index)
            {
                return *Mutable(index);
            }

            const Element& at(int index) const;
            Element& at(int index);

            // Removes the last element in the array.
            // Ownership of the element is retained by the array.
            void RemoveLast();

            // Deletes elements with indices in the range [start .. start+num-1].
            // Caution: moves all elements with indices [start+num .. ].
            // Calling this routine inside a loop can cause quadratic behavior.
            void DeleteSubrange(int start, int num);

            PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear();
            void MergeFrom(const RepeatedPtrField& other);
            PROTOBUF_ATTRIBUTE_REINITIALIZES void CopyFrom(const RepeatedPtrField& other);

            // Replaces the contents with RepeatedPtrField(begin, end).
            template<typename Iter>
            PROTOBUF_ATTRIBUTE_REINITIALIZES void Assign(Iter begin, Iter end);

            // Reserves space to expand the field to at least the given size.  This only
            // resizes the pointer array; it doesn't allocate any objects.  If the
            // array is grown, it will always be at least doubled in size.
            void Reserve(int new_size);

            int Capacity() const;

            // Gets the underlying array.  This pointer is possibly invalidated by
            // any add or remove operation.
            //
            // This API is deprecated. Instead of directly working with element array,
            // use APIs in repeated_field_util.h; e.g. sorting, etc.
            PROTOBUF_DEPRECATED_MSG("Use APIs in repeated_field_util.h")
            Element** mutable_data();
            const Element* const* data() const;

            // Swaps entire contents with "other". If they are on separate arenas, then
            // copies data.
            void Swap(RepeatedPtrField* other);

            // Swaps entire contents with "other". Caller should guarantee that either
            // both fields are on the same arena or both are on the heap. Swapping between
            // different arenas with this function is disallowed and is caught via
            // GOOGLE_DCHECK.
            void UnsafeArenaSwap(RepeatedPtrField* other);

            // Swaps two elements.
            void SwapElements(int index1, int index2);

            // STL-like iterator support
            typedef internal::RepeatedPtrIterator<Element> iterator;
            typedef internal::RepeatedPtrIterator<const Element> const_iterator;
            typedef Element value_type;
            typedef value_type& reference;
            typedef const value_type& const_reference;
            typedef value_type* pointer;
            typedef const value_type* const_pointer;
            typedef int size_type;
            typedef ptrdiff_t difference_type;

            iterator begin();
            const_iterator begin() const;
            const_iterator cbegin() const;
            iterator end();
            const_iterator end() const;
            const_iterator cend() const;

            // Reverse iterator support
            typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
            typedef std::reverse_iterator<iterator> reverse_iterator;
            reverse_iterator rbegin()
            {
                return reverse_iterator(end());
            }
            const_reverse_iterator rbegin() const
            {
                return const_reverse_iterator(end());
            }
            reverse_iterator rend()
            {
                return reverse_iterator(begin());
            }
            const_reverse_iterator rend() const
            {
                return const_reverse_iterator(begin());
            }

            // Custom STL-like iterator that iterates over and returns the underlying
            // pointers to Element rather than Element itself.
            typedef internal::RepeatedPtrOverPtrsIterator<Element*, void*>
                pointer_iterator;
            typedef internal::RepeatedPtrOverPtrsIterator<const Element* const, const void* const>
                const_pointer_iterator;
            pointer_iterator pointer_begin();
            const_pointer_iterator pointer_begin() const;
            pointer_iterator pointer_end();
            const_pointer_iterator pointer_end() const;

            // Returns (an estimate of) the number of bytes used by the repeated field,
            // excluding sizeof(*this).
            size_t SpaceUsedExcludingSelfLong() const;

            int SpaceUsedExcludingSelf() const
            {
                return internal::ToIntSize(SpaceUsedExcludingSelfLong());
            }

            // Advanced memory management --------------------------------------
            // When hardcore memory management becomes necessary -- as it sometimes
            // does here at Google -- the following methods may be useful.

            // Adds an already-allocated object, passing ownership to the
            // RepeatedPtrField.
            //
            // Note that some special behavior occurs with respect to arenas:
            //
            //   (i) if this field holds submessages, the new submessage will be copied if
            //   the original is in an arena and this RepeatedPtrField is either in a
            //   different arena, or on the heap.
            //   (ii) if this field holds strings, the passed-in string *must* be
            //   heap-allocated, not arena-allocated. There is no way to dynamically check
            //   this at runtime, so User Beware.
            void AddAllocated(Element* value);

            // Removes and returns the last element, passing ownership to the caller.
            // Requires:  size() > 0
            //
            // If this RepeatedPtrField is on an arena, an object copy is required to pass
            // ownership back to the user (for compatible semantics). Use
            // UnsafeArenaReleaseLast() if this behavior is undesired.
            PROTOBUF_NODISCARD Element* ReleaseLast();

            // Adds an already-allocated object, skipping arena-ownership checks. The user
            // must guarantee that the given object is in the same arena as this
            // RepeatedPtrField.
            // It is also useful in legacy code that uses temporary ownership to avoid
            // copies. Example:
            //   RepeatedPtrField<T> temp_field;
            //   temp_field.UnsafeArenaAddAllocated(new T);
            //   ... // Do something with temp_field
            //   temp_field.UnsafeArenaExtractSubrange(0, temp_field.size(), nullptr);
            // If you put temp_field on the arena this fails, because the ownership
            // transfers to the arena at the "AddAllocated" call and is not released
            // anymore, causing a double delete. UnsafeArenaAddAllocated prevents this.
            void UnsafeArenaAddAllocated(Element* value);

            // Removes and returns the last element.  Unlike ReleaseLast, the returned
            // pointer is always to the original object.  This may be in an arena, in
            // which case it would have the arena's lifetime.
            // Requires: current_size_ > 0
            Element* UnsafeArenaReleaseLast();

            // Extracts elements with indices in the range "[start .. start+num-1]".
            // The caller assumes ownership of the extracted elements and is responsible
            // for deleting them when they are no longer needed.
            // If "elements" is non-nullptr, then pointers to the extracted elements
            // are stored in "elements[0 .. num-1]" for the convenience of the caller.
            // If "elements" is nullptr, then the caller must use some other mechanism
            // to perform any further operations (like deletion) on these elements.
            // Caution: implementation also moves elements with indices [start+num ..].
            // Calling this routine inside a loop can cause quadratic behavior.
            //
            // Memory copying behavior is identical to ReleaseLast(), described above: if
            // this RepeatedPtrField is on an arena, an object copy is performed for each
            // returned element, so that all returned element pointers are to
            // heap-allocated copies. If this copy is not desired, the user should call
            // UnsafeArenaExtractSubrange().
            void ExtractSubrange(int start, int num, Element** elements);

            // Identical to ExtractSubrange() described above, except that no object
            // copies are ever performed. Instead, the raw object pointers are returned.
            // Thus, if on an arena, the returned objects must not be freed, because they
            // will not be heap-allocated objects.
            void UnsafeArenaExtractSubrange(int start, int num, Element** elements);

            // When elements are removed by calls to RemoveLast() or Clear(), they
            // are not actually freed.  Instead, they are cleared and kept so that
            // they can be reused later.  This can save lots of CPU time when
            // repeatedly reusing a protocol message for similar purposes.
            //
            // Hardcore programs may choose to manipulate these cleared objects
            // to better optimize memory management using the following routines.

            // Gets the number of cleared objects that are currently being kept
            // around for reuse.
            int ClearedCount() const;
#ifndef PROTOBUF_FUTURE_BREAKING_CHANGES
            // Adds an element to the pool of cleared objects, passing ownership to
            // the RepeatedPtrField.  The element must be cleared prior to calling
            // this method.
            //
            // This method cannot be called when either the repeated field or |value| is
            // on an arena; both cases will trigger a GOOGLE_DCHECK-failure.
            void AddCleared(Element* value);
            // Removes and returns a single element from the cleared pool, passing
            // ownership to the caller.  The element is guaranteed to be cleared.
            // Requires:  ClearedCount() > 0
            //
            // This method cannot be called when the repeated field is on an arena; doing
            // so will trigger a GOOGLE_DCHECK-failure.
            PROTOBUF_NODISCARD Element* ReleaseCleared();
#endif  // !PROTOBUF_FUTURE_BREAKING_CHANGES

            // Removes the element referenced by position.
            //
            // Returns an iterator to the element immediately following the removed
            // element.
            //
            // Invalidates all iterators at or after the removed element, including end().
            iterator erase(const_iterator position);

            // Removes the elements in the range [first, last).
            //
            // Returns an iterator to the element immediately following the removed range.
            //
            // Invalidates all iterators at or after the removed range, including end().
            iterator erase(const_iterator first, const_iterator last);

            // Gets the arena on which this RepeatedPtrField stores its elements.
            inline Arena* GetArena() const;

            // For internal use only.
            //
            // This is public due to it being called by generated code.
            void InternalSwap(RepeatedPtrField* other)
            {
                internal::RepeatedPtrFieldBase::InternalSwap(other);
            }

        private:
            // Note:  RepeatedPtrField SHOULD NOT be subclassed by users.
            class TypeHandler;

            // Internal version of GetArena().
            inline Arena* GetOwningArena() const;

            // Implementations for ExtractSubrange(). The copying behavior must be
            // included only if the type supports the necessary operations (e.g.,
            // MergeFrom()), so we must resolve this at compile time. ExtractSubrange()
            // uses SFINAE to choose one of the below implementations.
            void ExtractSubrangeInternal(int start, int num, Element** elements, std::true_type);
            void ExtractSubrangeInternal(int start, int num, Element** elements, std::false_type);

            friend class Arena;

            template<typename T>
            friend struct WeakRepeatedPtrField;

            typedef void InternalArenaConstructable_;
        };

        // -------------------------------------------------------------------

        template<typename Element>
        class RepeatedPtrField<Element>::TypeHandler : public internal::GenericTypeHandler<Element>
        {
        };

        template<>
        class RepeatedPtrField<std::string>::TypeHandler : public internal::StringTypeHandler
        {
        };

        template<typename Element>
        constexpr RepeatedPtrField<Element>::RepeatedPtrField() :
            RepeatedPtrFieldBase()
        {
        }

        template<typename Element>
        inline RepeatedPtrField<Element>::RepeatedPtrField(Arena* arena) :
            RepeatedPtrFieldBase(arena)
        {
        }

        template<typename Element>
        inline RepeatedPtrField<Element>::RepeatedPtrField(
            const RepeatedPtrField& other
        ) :
            RepeatedPtrFieldBase()
        {
            MergeFrom(other);
        }

        template<typename Element>
        template<typename Iter, typename>
        inline RepeatedPtrField<Element>::RepeatedPtrField(Iter begin, Iter end)
        {
            Add(begin, end);
        }

        template<typename Element>
        RepeatedPtrField<Element>::~RepeatedPtrField()
        {
#ifdef __cpp_if_constexpr
            if constexpr (std::is_base_of<MessageLite, Element>::value)
            {
#else
            if (std::is_base_of<MessageLite, Element>::value)
            {
#endif
                if (NeedsDestroy())
                    DestroyProtos();
            }
            else
            {
                Destroy<TypeHandler>();
            }
        }

        template<typename Element>
        inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
            const RepeatedPtrField& other
        )
        {
            if (this != &other)
                CopyFrom(other);
            return *this;
        }

        template<typename Element>
        inline RepeatedPtrField<Element>::RepeatedPtrField(
            RepeatedPtrField&& other
        ) noexcept
            :
            RepeatedPtrField()
        {
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
            CopyFrom(other);
#else   // PROTOBUF_FORCE_COPY_IN_MOVE
        // We don't just call Swap(&other) here because it would perform 3 copies if
        // other is on an arena. This field can't be on an arena because arena
        // construction always uses the Arena* accepting constructor.
            if (other.GetOwningArena())
            {
                CopyFrom(other);
            }
            else
            {
                InternalSwap(&other);
            }
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
        }

        template<typename Element>
        inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
            RepeatedPtrField&& other
        ) noexcept
        {
            // We don't just call Swap(&other) here because it would perform 3 copies if
            // the two fields are on different arenas.
            if (this != &other)
            {
                if (GetOwningArena() != other.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
                    || GetOwningArena() == nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
                )
                {
                    CopyFrom(other);
                }
                else
                {
                    InternalSwap(&other);
                }
            }
            return *this;
        }

        template<typename Element>
        inline bool RepeatedPtrField<Element>::empty() const
        {
            return RepeatedPtrFieldBase::empty();
        }

        template<typename Element>
        inline int RepeatedPtrField<Element>::size() const
        {
            return RepeatedPtrFieldBase::size();
        }

        template<typename Element>
        inline const Element& RepeatedPtrField<Element>::Get(int index) const
        {
            return RepeatedPtrFieldBase::Get<TypeHandler>(index);
        }

        template<typename Element>
        inline const Element& RepeatedPtrField<Element>::at(int index) const
        {
            return RepeatedPtrFieldBase::at<TypeHandler>(index);
        }

        template<typename Element>
        inline Element& RepeatedPtrField<Element>::at(int index)
        {
            return RepeatedPtrFieldBase::at<TypeHandler>(index);
        }

        template<typename Element>
        inline Element* RepeatedPtrField<Element>::Mutable(int index)
        {
            return RepeatedPtrFieldBase::Mutable<TypeHandler>(index);
        }

        template<typename Element>
        inline Element* RepeatedPtrField<Element>::Add()
        {
            return RepeatedPtrFieldBase::Add<TypeHandler>();
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::Add(Element&& value)
        {
            RepeatedPtrFieldBase::Add<TypeHandler>(std::move(value));
        }

        template<typename Element>
        template<typename Iter>
        inline void RepeatedPtrField<Element>::Add(Iter begin, Iter end)
        {
            if (std::is_base_of<
                    std::forward_iterator_tag,
                    typename std::iterator_traits<Iter>::iterator_category>::value)
            {
                int reserve = std::distance(begin, end);
                Reserve(size() + reserve);
            }
            for (; begin != end; ++begin)
            {
                *Add() = *begin;
            }
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::RemoveLast()
        {
            RepeatedPtrFieldBase::RemoveLast<TypeHandler>();
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::DeleteSubrange(int start, int num)
        {
            GOOGLE_DCHECK_GE(start, 0);
            GOOGLE_DCHECK_GE(num, 0);
            GOOGLE_DCHECK_LE(start + num, size());
            for (int i = 0; i < num; ++i)
            {
                RepeatedPtrFieldBase::Delete<TypeHandler>(start + i);
            }
            UnsafeArenaExtractSubrange(start, num, nullptr);
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::ExtractSubrange(int start, int num, Element** elements)
        {
            typename internal::TypeImplementsMergeBehavior<
                typename TypeHandler::Type>::type t;
            ExtractSubrangeInternal(start, num, elements, t);
        }

        // ExtractSubrange() implementation for types that implement merge/copy
        // behavior.
        template<typename Element>
        inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
            int start, int num, Element** elements, std::true_type
        )
        {
            GOOGLE_DCHECK_GE(start, 0);
            GOOGLE_DCHECK_GE(num, 0);
            GOOGLE_DCHECK_LE(start + num, size());

            if (num == 0)
                return;

            GOOGLE_DCHECK_NE(elements, nullptr)
                << "Releasing elements without transferring ownership is an unsafe "
                   "operation.  Use UnsafeArenaExtractSubrange.";
            if (elements == nullptr)
            {
                CloseGap(start, num);
                return;
            }

            Arena* arena = GetOwningArena();
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
            // Always copy.
            for (int i = 0; i < num; ++i)
            {
                elements[i] = copy<TypeHandler>(
                    RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start)
                );
            }
            if (arena == nullptr)
            {
                for (int i = 0; i < num; ++i)
                {
                    delete RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
                }
            }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
        // If we're on an arena, we perform a copy for each element so that the
        // returned elements are heap-allocated. Otherwise, just forward it.
            if (arena != nullptr)
            {
                for (int i = 0; i < num; ++i)
                {
                    elements[i] = copy<TypeHandler>(
                        RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start)
                    );
                }
            }
            else
            {
                for (int i = 0; i < num; ++i)
                {
                    elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
                }
            }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
            CloseGap(start, num);
        }

        // ExtractSubrange() implementation for types that do not implement merge/copy
        // behavior.
        template<typename Element>
        inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
            int start, int num, Element** elements, std::false_type
        )
        {
            // This case is identical to UnsafeArenaExtractSubrange(). However, since
            // ExtractSubrange() must return heap-allocated objects by contract, and we
            // cannot fulfill this contract if we are an on arena, we must GOOGLE_DCHECK() that
            // we are not on an arena.
            GOOGLE_DCHECK(GetOwningArena() == nullptr)
                << "ExtractSubrange() when arena is non-nullptr is only supported when "
                << "the Element type supplies a MergeFrom() operation to make copies.";
            UnsafeArenaExtractSubrange(start, num, elements);
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::UnsafeArenaExtractSubrange(
            int start, int num, Element** elements
        )
        {
            GOOGLE_DCHECK_GE(start, 0);
            GOOGLE_DCHECK_GE(num, 0);
            GOOGLE_DCHECK_LE(start + num, size());

            if (num > 0)
            {
                // Save the values of the removed elements if requested.
                if (elements != nullptr)
                {
                    for (int i = 0; i < num; ++i)
                    {
                        elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
                    }
                }
                CloseGap(start, num);
            }
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::Clear()
        {
            RepeatedPtrFieldBase::Clear<TypeHandler>();
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::MergeFrom(
            const RepeatedPtrField& other
        )
        {
            RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::CopyFrom(const RepeatedPtrField& other)
        {
            RepeatedPtrFieldBase::CopyFrom<TypeHandler>(other);
        }

        template<typename Element>
        template<typename Iter>
        inline void RepeatedPtrField<Element>::Assign(Iter begin, Iter end)
        {
            Clear();
            Add(begin, end);
        }

        template<typename Element>
        inline typename RepeatedPtrField<Element>::iterator
            RepeatedPtrField<Element>::erase(const_iterator position)
        {
            return erase(position, position + 1);
        }

        template<typename Element>
        inline typename RepeatedPtrField<Element>::iterator
            RepeatedPtrField<Element>::erase(const_iterator first, const_iterator last)
        {
            size_type pos_offset = std::distance(cbegin(), first);
            size_type last_offset = std::distance(cbegin(), last);
            DeleteSubrange(pos_offset, last_offset - pos_offset);
            return begin() + pos_offset;
        }

        template<typename Element>
        inline Element** RepeatedPtrField<Element>::mutable_data()
        {
            return RepeatedPtrFieldBase::mutable_data<TypeHandler>();
        }

        template<typename Element>
        inline const Element* const* RepeatedPtrField<Element>::data() const
        {
            return RepeatedPtrFieldBase::data<TypeHandler>();
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::Swap(RepeatedPtrField* other)
        {
            if (this == other)
                return;
            RepeatedPtrFieldBase::Swap<TypeHandler>(other);
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::UnsafeArenaSwap(
            RepeatedPtrField* other
        )
        {
            if (this == other)
                return;
            GOOGLE_DCHECK_EQ(GetOwningArena(), other->GetOwningArena());
            RepeatedPtrFieldBase::InternalSwap(other);
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::SwapElements(int index1, int index2)
        {
            RepeatedPtrFieldBase::SwapElements(index1, index2);
        }

        template<typename Element>
        inline Arena* RepeatedPtrField<Element>::GetArena() const
        {
            return RepeatedPtrFieldBase::GetArena();
        }

        template<typename Element>
        inline Arena* RepeatedPtrField<Element>::GetOwningArena() const
        {
            return RepeatedPtrFieldBase::GetOwningArena();
        }

        template<typename Element>
        inline size_t RepeatedPtrField<Element>::SpaceUsedExcludingSelfLong() const
        {
            return RepeatedPtrFieldBase::SpaceUsedExcludingSelfLong<TypeHandler>();
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::AddAllocated(Element* value)
        {
            RepeatedPtrFieldBase::AddAllocated<TypeHandler>(value);
        }

        template<typename Element>
        inline void RepeatedPtrField<Element>::UnsafeArenaAddAllocated(Element* value)
        {
            RepeatedPtrFieldBase::UnsafeArenaAddAllocated<TypeHandler>(value);
        }

        template<typename Element>
        inline Element* RepeatedPtrField<Element>::ReleaseLast()
        {
            return RepeatedPtrFieldBase::ReleaseLast<TypeHandler>();
        }

        template<typename Element>
        inline Element* RepeatedPtrField<Element>::UnsafeArenaReleaseLast()
        {
            return RepeatedPtrFieldBase::UnsafeArenaReleaseLast<TypeHandler>();
        }

        template<typename Element>
        inline int RepeatedPtrField<Element>::ClearedCount() const
        {
            return RepeatedPtrFieldBase::ClearedCount();
        }

#ifndef PROTOBUF_FUTURE_BREAKING_CHANGES
        template<typename Element>
        inline void RepeatedPtrField<Element>::AddCleared(Element* value)
        {
            return RepeatedPtrFieldBase::AddCleared<TypeHandler>(value);
        }

        template<typename Element>
        inline Element* RepeatedPtrField<Element>::ReleaseCleared()
        {
            return RepeatedPtrFieldBase::ReleaseCleared<TypeHandler>();
        }
#endif  // !PROTOBUF_FUTURE_BREAKING_CHANGES

        template<typename Element>
        inline void RepeatedPtrField<Element>::Reserve(int new_size)
        {
            return RepeatedPtrFieldBase::Reserve(new_size);
        }

        template<typename Element>
        inline int RepeatedPtrField<Element>::Capacity() const
        {
            return RepeatedPtrFieldBase::Capacity();
        }

        // -------------------------------------------------------------------

        namespace internal
        {

            // STL-like iterator implementation for RepeatedPtrField.  You should not
            // refer to this class directly; use RepeatedPtrField<T>::iterator instead.
            //
            // The iterator for RepeatedPtrField<T>, RepeatedPtrIterator<T>, is
            // very similar to iterator_ptr<T**> in util/gtl/iterator_adaptors.h,
            // but adds random-access operators and is modified to wrap a void** base
            // iterator (since RepeatedPtrField stores its array as a void* array and
            // casting void** to T** would violate C++ aliasing rules).
            //
            // This code based on net/proto/proto-array-internal.h by Jeffrey Yasskin
            // (jyasskin@google.com).
            template<typename Element>
            class RepeatedPtrIterator
            {
            public:
                using iterator = RepeatedPtrIterator<Element>;
                using iterator_category = std::random_access_iterator_tag;
                using value_type = typename std::remove_const<Element>::type;
                using difference_type = std::ptrdiff_t;
                using pointer = Element*;
                using reference = Element&;

                RepeatedPtrIterator() :
                    it_(nullptr)
                {
                }
                explicit RepeatedPtrIterator(void* const* it) :
                    it_(it)
                {
                }

                // Allows "upcasting" from RepeatedPtrIterator<T**> to
                // RepeatedPtrIterator<const T*const*>.
                template<typename OtherElement, typename std::enable_if<std::is_convertible<OtherElement*, pointer>::value>::type* = nullptr>
                RepeatedPtrIterator(const RepeatedPtrIterator<OtherElement>& other) :
                    it_(other.it_)
                {
                }

                // dereferenceable
                reference operator*() const
                {
                    return *reinterpret_cast<Element*>(*it_);
                }
                pointer operator->() const
                {
                    return &(operator*());
                }

                // {inc,dec}rementable
                iterator& operator++()
                {
                    ++it_;
                    return *this;
                }
                iterator operator++(int)
                {
                    return iterator(it_++);
                }
                iterator& operator--()
                {
                    --it_;
                    return *this;
                }
                iterator operator--(int)
                {
                    return iterator(it_--);
                }

                // equality_comparable
                friend bool operator==(const iterator& x, const iterator& y)
                {
                    return x.it_ == y.it_;
                }
                friend bool operator!=(const iterator& x, const iterator& y)
                {
                    return x.it_ != y.it_;
                }

                // less_than_comparable
                friend bool operator<(const iterator& x, const iterator& y)
                {
                    return x.it_ < y.it_;
                }
                friend bool operator<=(const iterator& x, const iterator& y)
                {
                    return x.it_ <= y.it_;
                }
                friend bool operator>(const iterator& x, const iterator& y)
                {
                    return x.it_ > y.it_;
                }
                friend bool operator>=(const iterator& x, const iterator& y)
                {
                    return x.it_ >= y.it_;
                }

                // addable, subtractable
                iterator& operator+=(difference_type d)
                {
                    it_ += d;
                    return *this;
                }
                friend iterator operator+(iterator it, const difference_type d)
                {
                    it += d;
                    return it;
                }
                friend iterator operator+(const difference_type d, iterator it)
                {
                    it += d;
                    return it;
                }
                iterator& operator-=(difference_type d)
                {
                    it_ -= d;
                    return *this;
                }
                friend iterator operator-(iterator it, difference_type d)
                {
                    it -= d;
                    return it;
                }

                // indexable
                reference operator[](difference_type d) const
                {
                    return *(*this + d);
                }

                // random access iterator
                friend difference_type operator-(iterator it1, iterator it2)
                {
                    return it1.it_ - it2.it_;
                }

            private:
                template<typename OtherElement>
                friend class RepeatedPtrIterator;

                // The internal iterator.
                void* const* it_;
            };

            // Provides an iterator that operates on pointers to the underlying objects
            // rather than the objects themselves as RepeatedPtrIterator does.
            // Consider using this when working with stl algorithms that change
            // the array.
            // The VoidPtr template parameter holds the type-agnostic pointer value
            // referenced by the iterator.  It should either be "void *" for a mutable
            // iterator, or "const void* const" for a constant iterator.
            template<typename Element, typename VoidPtr>
            class RepeatedPtrOverPtrsIterator
            {
            public:
                using iterator = RepeatedPtrOverPtrsIterator<Element, VoidPtr>;
                using iterator_category = std::random_access_iterator_tag;
                using value_type = typename std::remove_const<Element>::type;
                using difference_type = std::ptrdiff_t;
                using pointer = Element*;
                using reference = Element&;

                RepeatedPtrOverPtrsIterator() :
                    it_(nullptr)
                {
                }
                explicit RepeatedPtrOverPtrsIterator(VoidPtr* it) :
                    it_(it)
                {
                }

                // Allows "upcasting" from RepeatedPtrOverPtrsIterator<T**> to
                // RepeatedPtrOverPtrsIterator<const T*const*>.
                template<
                    typename OtherElement,
                    typename OtherVoidPtr,
                    typename std::enable_if<
                        std::is_convertible<OtherElement*, pointer>::value &&
                        std::is_convertible<OtherVoidPtr*, VoidPtr>::value>::type* = nullptr>
                RepeatedPtrOverPtrsIterator(
                    const RepeatedPtrOverPtrsIterator<OtherElement, OtherVoidPtr>& other
                ) :
                    it_(other.it_)
                {
                }

                // dereferenceable
                reference operator*() const
                {
                    return *reinterpret_cast<Element*>(it_);
                }
                pointer operator->() const
                {
                    return &(operator*());
                }

                // {inc,dec}rementable
                iterator& operator++()
                {
                    ++it_;
                    return *this;
                }
                iterator operator++(int)
                {
                    return iterator(it_++);
                }
                iterator& operator--()
                {
                    --it_;
                    return *this;
                }
                iterator operator--(int)
                {
                    return iterator(it_--);
                }

                // equality_comparable
                friend bool operator==(const iterator& x, const iterator& y)
                {
                    return x.it_ == y.it_;
                }
                friend bool operator!=(const iterator& x, const iterator& y)
                {
                    return x.it_ != y.it_;
                }

                // less_than_comparable
                friend bool operator<(const iterator& x, const iterator& y)
                {
                    return x.it_ < y.it_;
                }
                friend bool operator<=(const iterator& x, const iterator& y)
                {
                    return x.it_ <= y.it_;
                }
                friend bool operator>(const iterator& x, const iterator& y)
                {
                    return x.it_ > y.it_;
                }
                friend bool operator>=(const iterator& x, const iterator& y)
                {
                    return x.it_ >= y.it_;
                }

                // addable, subtractable
                iterator& operator+=(difference_type d)
                {
                    it_ += d;
                    return *this;
                }
                friend iterator operator+(iterator it, difference_type d)
                {
                    it += d;
                    return it;
                }
                friend iterator operator+(difference_type d, iterator it)
                {
                    it += d;
                    return it;
                }
                iterator& operator-=(difference_type d)
                {
                    it_ -= d;
                    return *this;
                }
                friend iterator operator-(iterator it, difference_type d)
                {
                    it -= d;
                    return it;
                }

                // indexable
                reference operator[](difference_type d) const
                {
                    return *(*this + d);
                }

                // random access iterator
                friend difference_type operator-(iterator it1, iterator it2)
                {
                    return it1.it_ - it2.it_;
                }

            private:
                template<typename OtherElement, typename OtherVoidPtr>
                friend class RepeatedPtrOverPtrsIterator;

                // The internal iterator.
                VoidPtr* it_;
            };

        }  // namespace internal

        template<typename Element>
        inline typename RepeatedPtrField<Element>::iterator
            RepeatedPtrField<Element>::begin()
        {
            return iterator(raw_data());
        }
        template<typename Element>
        inline typename RepeatedPtrField<Element>::const_iterator
            RepeatedPtrField<Element>::begin() const
        {
            return iterator(raw_data());
        }
        template<typename Element>
        inline typename RepeatedPtrField<Element>::const_iterator
            RepeatedPtrField<Element>::cbegin() const
        {
            return begin();
        }
        template<typename Element>
        inline typename RepeatedPtrField<Element>::iterator
            RepeatedPtrField<Element>::end()
        {
            return iterator(raw_data() + size());
        }
        template<typename Element>
        inline typename RepeatedPtrField<Element>::const_iterator
            RepeatedPtrField<Element>::end() const
        {
            return iterator(raw_data() + size());
        }
        template<typename Element>
        inline typename RepeatedPtrField<Element>::const_iterator
            RepeatedPtrField<Element>::cend() const
        {
            return end();
        }

        template<typename Element>
        inline typename RepeatedPtrField<Element>::pointer_iterator
            RepeatedPtrField<Element>::pointer_begin()
        {
            return pointer_iterator(raw_mutable_data());
        }
        template<typename Element>
        inline typename RepeatedPtrField<Element>::const_pointer_iterator
            RepeatedPtrField<Element>::pointer_begin() const
        {
            return const_pointer_iterator(const_cast<const void* const*>(raw_data()));
        }
        template<typename Element>
        inline typename RepeatedPtrField<Element>::pointer_iterator
            RepeatedPtrField<Element>::pointer_end()
        {
            return pointer_iterator(raw_mutable_data() + size());
        }
        template<typename Element>
        inline typename RepeatedPtrField<Element>::const_pointer_iterator
            RepeatedPtrField<Element>::pointer_end() const
        {
            return const_pointer_iterator(
                const_cast<const void* const*>(raw_data() + size())
            );
        }

        // Iterators and helper functions that follow the spirit of the STL
        // std::back_insert_iterator and std::back_inserter but are tailor-made
        // for RepeatedField and RepeatedPtrField. Typical usage would be:
        //
        //   std::copy(some_sequence.begin(), some_sequence.end(),
        //             RepeatedFieldBackInserter(proto.mutable_sequence()));
        //
        // Ported by johannes from util/gtl/proto-array-iterators.h

        namespace internal
        {

            // A back inserter for RepeatedPtrField objects.
            template<typename T>
            class RepeatedPtrFieldBackInsertIterator
            {
            public:
                using iterator_category = std::output_iterator_tag;
                using value_type = T;
                using pointer = void;
                using reference = void;
                using difference_type = std::ptrdiff_t;

                RepeatedPtrFieldBackInsertIterator(RepeatedPtrField<T>* const mutable_field) :
                    field_(mutable_field)
                {
                }
                RepeatedPtrFieldBackInsertIterator<T>& operator=(const T& value)
                {
                    *field_->Add() = value;
                    return *this;
                }
                RepeatedPtrFieldBackInsertIterator<T>& operator=(
                    const T* const ptr_to_value
                )
                {
                    *field_->Add() = *ptr_to_value;
                    return *this;
                }
                RepeatedPtrFieldBackInsertIterator<T>& operator=(T&& value)
                {
                    *field_->Add() = std::move(value);
                    return *this;
                }
                RepeatedPtrFieldBackInsertIterator<T>& operator*()
                {
                    return *this;
                }
                RepeatedPtrFieldBackInsertIterator<T>& operator++()
                {
                    return *this;
                }
                RepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */)
                {
                    return *this;
                }

            private:
                RepeatedPtrField<T>* field_;
            };

            // A back inserter for RepeatedPtrFields that inserts by transferring ownership
            // of a pointer.
            template<typename T>
            class AllocatedRepeatedPtrFieldBackInsertIterator
            {
            public:
                using iterator_category = std::output_iterator_tag;
                using value_type = T;
                using pointer = void;
                using reference = void;
                using difference_type = std::ptrdiff_t;

                explicit AllocatedRepeatedPtrFieldBackInsertIterator(
                    RepeatedPtrField<T>* const mutable_field
                ) :
                    field_(mutable_field)
                {
                }
                AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
                    T* const ptr_to_value
                )
                {
                    field_->AddAllocated(ptr_to_value);
                    return *this;
                }
                AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*()
                {
                    return *this;
                }
                AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++()
                {
                    return *this;
                }
                AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */)
                {
                    return *this;
                }

            private:
                RepeatedPtrField<T>* field_;
            };

            // Almost identical to AllocatedRepeatedPtrFieldBackInsertIterator. This one
            // uses the UnsafeArenaAddAllocated instead.
            template<typename T>
            class UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator
            {
            public:
                using iterator_category = std::output_iterator_tag;
                using value_type = T;
                using pointer = void;
                using reference = void;
                using difference_type = std::ptrdiff_t;

                explicit UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator(
                    RepeatedPtrField<T>* const mutable_field
                ) :
                    field_(mutable_field)
                {
                }
                UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
                    T const* const ptr_to_value
                )
                {
                    field_->UnsafeArenaAddAllocated(const_cast<T*>(ptr_to_value));
                    return *this;
                }
                UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*()
                {
                    return *this;
                }
                UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++()
                {
                    return *this;
                }
                UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(
                    int /* unused */
                )
                {
                    return *this;
                }

            private:
                RepeatedPtrField<T>* field_;
            };

        }  // namespace internal

        // Provides a back insert iterator for RepeatedPtrField instances,
        // similar to std::back_inserter().
        template<typename T>
        internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedPtrFieldBackInserter(
            RepeatedPtrField<T>* const mutable_field
        )
        {
            return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
        }

        // Special back insert iterator for RepeatedPtrField instances, just in
        // case someone wants to write generic template code that can access both
        // RepeatedFields and RepeatedPtrFields using a common name.
        template<typename T>
        internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedFieldBackInserter(
            RepeatedPtrField<T>* const mutable_field
        )
        {
            return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
        }

        // Provides a back insert iterator for RepeatedPtrField instances
        // similar to std::back_inserter() which transfers the ownership while
        // copying elements.
        template<typename T>
        internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>
            AllocatedRepeatedPtrFieldBackInserter(
                RepeatedPtrField<T>* const mutable_field
            )
        {
            return internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>(
                mutable_field
            );
        }

        // Similar to AllocatedRepeatedPtrFieldBackInserter, using
        // UnsafeArenaAddAllocated instead of AddAllocated.
        // This is slightly faster if that matters. It is also useful in legacy code
        // that uses temporary ownership to avoid copies. Example:
        //   RepeatedPtrField<T> temp_field;
        //   temp_field.UnsafeArenaAddAllocated(new T);
        //   ... // Do something with temp_field
        //   temp_field.UnsafeArenaExtractSubrange(0, temp_field.size(), nullptr);
        // Putting temp_field on the arena fails because the ownership transfers to the
        // arena at the "AddAllocated" call and is not released anymore causing a
        // double delete. This function uses UnsafeArenaAddAllocated to prevent this.
        template<typename T>
        internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>
            UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
                RepeatedPtrField<T>* const mutable_field
            )
        {
            return internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>(
                mutable_field
            );
        }

        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
            RepeatedPtrField<std::string>;

    }  // namespace protobuf
}  // namespace google

#include <google/protobuf/port_undef.inc>

#endif  // GOOGLE_PROTOBUF_REPEATED_PTR_FIELD_H__