diff options
Diffstat (limited to 'include/google/protobuf/repeated_ptr_field.h')
| -rw-r--r-- | include/google/protobuf/repeated_ptr_field.h | 1970 |
1 files changed, 0 insertions, 1970 deletions
diff --git a/include/google/protobuf/repeated_ptr_field.h b/include/google/protobuf/repeated_ptr_field.h deleted file mode 100644 index 401230bf51..0000000000 --- a/include/google/protobuf/repeated_ptr_field.h +++ /dev/null @@ -1,1970 +0,0 @@ -// 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__ |