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

File indexing completed on 2025-01-31 10:12:24

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 
 // This header defines the RepeatedFieldRef class template used to access
 // repeated fields with protobuf reflection API.
 #ifndef GOOGLE_PROTOBUF_REFLECTION_H__
 #define GOOGLE_PROTOBUF_REFLECTION_H__
 
 #include <memory>
 #include <type_traits>
 
 #include "google/protobuf/generated_enum_util.h"
 #include "google/protobuf/descriptor.h"
 
 #ifdef SWIG
 #error "You cannot SWIG proto headers"
 #endif
 
 // Must be included last.
 #include "google/protobuf/port_def.inc"
 
 namespace google {
 namespace protobuf {
 namespace internal {
 template <typename T, typename Enable = void>
 struct RefTypeTraits;
 }  // namespace internal
 
 class Message;
 
 template <typename Dep, typename T>
 using MakeDependent = std::conditional_t<true, T, Dep>;
 
 // Forward-declare RepeatedFieldRef templates. The second type parameter is
 // used for SFINAE tricks. Users should ignore it.
 template <typename T, typename Enable = void>
 class RepeatedFieldRef;
 
 template <typename T, typename Enable = void>
 class MutableRepeatedFieldRef;
 
 // RepeatedFieldRef definition for non-message types.
 template <typename T>
 class RepeatedFieldRef<
     T, typename std::enable_if<!std::is_base_of<Message, T>::value>::type> {
   typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
   typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
 
  public:
   bool empty() const { return accessor_->IsEmpty(data_); }
   int size() const { return accessor_->Size(data_); }
   T Get(int index) const { return accessor_->template Get<T>(data_, index); }
 
   typedef IteratorType iterator;
   typedef IteratorType const_iterator;
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef int size_type;
   typedef ptrdiff_t difference_type;
 
   iterator begin() const { return iterator(data_, accessor_, true); }
   iterator end() const { return iterator(data_, accessor_, false); }
 
  private:
   friend class Reflection;
   RepeatedFieldRef(const MakeDependent<T, Message>& message,
                    const FieldDescriptor* field) {
     const auto* reflection = message.GetReflection();
     data_ = reflection->RepeatedFieldData(
         message, field, internal::RefTypeTraits<T>::cpp_type, nullptr);
     accessor_ = reflection->RepeatedFieldAccessor(field);
   }
 
   const void* data_;
   const AccessorType* accessor_;
 };
 
 // MutableRepeatedFieldRef definition for non-message types.
 template <typename T>
 class MutableRepeatedFieldRef<
     T, typename std::enable_if<!std::is_base_of<Message, T>::value>::type> {
   typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
 
  public:
   bool empty() const { return accessor_->IsEmpty(data_); }
   int size() const { return accessor_->Size(data_); }
   T Get(int index) const { return accessor_->template Get<T>(data_, index); }
 
   void Set(int index, const T& value) const {
     accessor_->template Set<T>(data_, index, value);
   }
   void Add(const T& value) const { accessor_->template Add<T>(data_, value); }
   void RemoveLast() const { accessor_->RemoveLast(data_); }
   void Reserve(int size) const { accessor_->Reserve(data_, size); }
   void SwapElements(int index1, int index2) const {
     accessor_->SwapElements(data_, index1, index2);
   }
   void Clear() const { accessor_->Clear(data_); }
 
   void Swap(const MutableRepeatedFieldRef& other) const {
     accessor_->Swap(data_, other.accessor_, other.data_);
   }
 
   template <typename Container>
   void MergeFrom(const Container& container) const {
     typedef typename Container::const_iterator Iterator;
     for (Iterator it = container.begin(); it != container.end(); ++it) {
       Add(*it);
     }
   }
   template <typename Container>
   void CopyFrom(const Container& container) const {
     Clear();
     MergeFrom(container);
   }
 
  private:
   friend class Reflection;
   MutableRepeatedFieldRef(MakeDependent<T, Message>* message,
                           const FieldDescriptor* field) {
     const auto* reflection = message->GetReflection();
     data_ = reflection->RepeatedFieldData(
         message, field, internal::RefTypeTraits<T>::cpp_type, nullptr);
     accessor_ = reflection->RepeatedFieldAccessor(field);
   }
 
   void* data_;
   const AccessorType* accessor_;
 };
 
 // RepeatedFieldRef definition for message types.
 template <typename T>
 class RepeatedFieldRef<
     T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
   typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
   typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
 
  public:
   bool empty() const { return accessor_->IsEmpty(data_); }
   int size() const { return accessor_->Size(data_); }
   // This method returns a reference to the underlying message object if it
   // exists. If a message object doesn't exist (e.g., data stored in serialized
   // form), scratch_space will be filled with the data and a reference to it
   // will be returned.
   //
   // Example:
   //   RepeatedFieldRef<Message> h = ...
   //   unique_ptr<Message> scratch_space(h.NewMessage());
   //   const Message& item = h.Get(index, scratch_space.get());
   const T& Get(int index, T* scratch_space) const {
     return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
   }
   // Create a new message of the same type as the messages stored in this
   // repeated field. Caller takes ownership of the returned object.
   T* NewMessage() const { return default_instance_->New(); }
 
   typedef IteratorType iterator;
   typedef IteratorType const_iterator;
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef int size_type;
   typedef ptrdiff_t difference_type;
 
   iterator begin() const {
     return iterator(data_, accessor_, true, NewMessage());
   }
   iterator end() const {
     // The end iterator must not be dereferenced, no need for scratch space.
     return iterator(data_, accessor_, false, nullptr);
   }
 
  private:
   friend class Reflection;
   RepeatedFieldRef(const MakeDependent<T, Message>& message,
                    const FieldDescriptor* field) {
     const auto* reflection = message.GetReflection();
     data_ = reflection->RepeatedFieldData(
         message, field, internal::RefTypeTraits<T>::cpp_type,
         internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
     accessor_ = reflection->RepeatedFieldAccessor(field);
     default_instance_ = static_cast<const T*>(
         reflection->GetMessageFactory()->GetPrototype(field->message_type()));
   }
 
   const void* data_;
   const AccessorType* accessor_;
   const T* default_instance_;
 };
 
 // MutableRepeatedFieldRef definition for message types.
 template <typename T>
 class MutableRepeatedFieldRef<
     T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
   typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
 
  public:
   bool empty() const { return accessor_->IsEmpty(data_); }
   int size() const { return accessor_->Size(data_); }
   // See comments for RepeatedFieldRef<Message>::Get()
   const T& Get(int index, T* scratch_space) const {
     return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
   }
   // Create a new message of the same type as the messages stored in this
   // repeated field. Caller takes ownership of the returned object.
   T* NewMessage() const { return default_instance_->New(); }
 
   void Set(int index, const T& value) const {
     accessor_->Set(data_, index, &value);
   }
   void Add(const T& value) const { accessor_->Add(data_, &value); }
   void RemoveLast() const { accessor_->RemoveLast(data_); }
   void Reserve(int size) const { accessor_->Reserve(data_, size); }
   void SwapElements(int index1, int index2) const {
     accessor_->SwapElements(data_, index1, index2);
   }
   void Clear() const { accessor_->Clear(data_); }
 
   void Swap(const MutableRepeatedFieldRef& other) const {
     accessor_->Swap(data_, other.accessor_, other.data_);
   }
 
   template <typename Container>
   void MergeFrom(const Container& container) const {
     typedef typename Container::const_iterator Iterator;
     for (Iterator it = container.begin(); it != container.end(); ++it) {
       Add(*it);
     }
   }
   template <typename Container>
   void CopyFrom(const Container& container) const {
     Clear();
     MergeFrom(container);
   }
 
  private:
   friend class Reflection;
   MutableRepeatedFieldRef(MakeDependent<T, Message>* message,
                           const FieldDescriptor* field) {
     const auto* reflection = message->GetReflection();
     data_ = reflection->RepeatedFieldData(
         message, field, internal::RefTypeTraits<T>::cpp_type,
         internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
     accessor_ = reflection->RepeatedFieldAccessor(field);
     default_instance_ = static_cast<const T*>(
         reflection->GetMessageFactory()->GetPrototype(field->message_type()));
   }
 
   void* data_;
   const AccessorType* accessor_;
   const T* default_instance_;
 };
 
 namespace internal {
 // Interfaces used to implement reflection RepeatedFieldRef API.
 // Reflection::GetRepeatedAccessor() should return a pointer to an singleton
 // object that implements the below interface.
 //
 // This interface passes/returns values using void pointers. The actual type
 // of the value depends on the field's cpp_type. Following is a mapping from
 // cpp_type to the type that should be used in this interface:
 //
 //   field->cpp_type()      T                Actual type of void*
 //   CPPTYPE_INT32        int32_t                 int32_t
 //   CPPTYPE_UINT32       uint32_t                uint32_t
 //   CPPTYPE_INT64        int64_t                 int64_t
 //   CPPTYPE_UINT64       uint64_t                uint64_t
 //   CPPTYPE_DOUBLE       double                  double
 //   CPPTYPE_FLOAT        float                   float
 //   CPPTYPE_BOOL         bool                    bool
 //   CPPTYPE_ENUM         generated enum type     int32_t
 //   CPPTYPE_STRING       string                  std::string
 //   CPPTYPE_MESSAGE      generated message type  google::protobuf::Message
 //                        or google::protobuf::Message
 //
 // Note that for enums we use int32_t in the interface.
 //
 // You can map from T to the actual type using RefTypeTraits:
 //   typedef RefTypeTraits<T>::AccessorValueType ActualType;
 class PROTOBUF_EXPORT RepeatedFieldAccessor {
  public:
   // Typedefs for clarity.
   typedef void Field;
   typedef void Value;
   typedef void Iterator;
 
   virtual bool IsEmpty(const Field* data) const = 0;
   virtual int Size(const Field* data) const = 0;
   // Depends on the underlying representation of the repeated field, this
   // method can return a pointer to the underlying object if such an object
   // exists, or fill the data into scratch_space and return scratch_space.
   // Callers of this method must ensure scratch_space is a valid pointer
   // to a mutable object of the correct type.
   virtual const Value* Get(const Field* data, int index,
                            Value* scratch_space) const = 0;
 
   virtual void Clear(Field* data) const = 0;
   virtual void Set(Field* data, int index, const Value* value) const = 0;
   virtual void Add(Field* data, const Value* value) const = 0;
   virtual void RemoveLast(Field* data) const = 0;
   virtual void Reserve(Field* data, int size) const = 0;
   virtual void SwapElements(Field* data, int index1, int index2) const = 0;
   virtual void Swap(Field* data, const RepeatedFieldAccessor* other_mutator,
                     Field* other_data) const = 0;
 
   // Create an iterator that points at the beginning of the repeated field.
   virtual Iterator* BeginIterator(const Field* data) const = 0;
   // Create an iterator that points at the end of the repeated field.
   virtual Iterator* EndIterator(const Field* data) const = 0;
   // Make a copy of an iterator and return the new copy.
   virtual Iterator* CopyIterator(const Field* data,
                                  const Iterator* iterator) const = 0;
   // Move an iterator to point to the next element.
   virtual Iterator* AdvanceIterator(const Field* data,
                                     Iterator* iterator) const = 0;
   // Compare whether two iterators point to the same element.
   virtual bool EqualsIterator(const Field* data, const Iterator* a,
                               const Iterator* b) const = 0;
   // Delete an iterator created by BeginIterator(), EndIterator() and
   // CopyIterator().
   virtual void DeleteIterator(const Field* data, Iterator* iterator) const = 0;
   // Like Get() but for iterators.
   virtual const Value* GetIteratorValue(const Field* data,
                                         const Iterator* iterator,
                                         Value* scratch_space) const = 0;
 
   // Templated methods that make using this interface easier for non-message
   // types.
   template <typename T>
   T Get(const Field* data, int index) const {
     typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
     ActualType scratch_space;
     return static_cast<T>(*reinterpret_cast<const ActualType*>(
         Get(data, index, static_cast<Value*>(&scratch_space))));
   }
 
   template <typename T, typename ValueType>
   void Set(Field* data, int index, const ValueType& value) const {
     typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
     // In this RepeatedFieldAccessor interface we pass/return data using
     // raw pointers. Type of the data these raw pointers point to should
     // be ActualType. Here we have a ValueType object and want a ActualType
     // pointer. We can't cast a ValueType pointer to an ActualType pointer
     // directly because their type might be different (for enums ValueType
     // may be a generated enum type while ActualType is int32_t). To be safe
     // we make a copy to get a temporary ActualType object and use it.
     ActualType tmp = static_cast<ActualType>(value);
     Set(data, index, static_cast<const Value*>(&tmp));
   }
 
   template <typename T, typename ValueType>
   void Add(Field* data, const ValueType& value) const {
     typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
     // In this RepeatedFieldAccessor interface we pass/return data using
     // raw pointers. Type of the data these raw pointers point to should
     // be ActualType. Here we have a ValueType object and want a ActualType
     // pointer. We can't cast a ValueType pointer to an ActualType pointer
     // directly because their type might be different (for enums ValueType
     // may be a generated enum type while ActualType is int32_t). To be safe
     // we make a copy to get a temporary ActualType object and use it.
     ActualType tmp = static_cast<ActualType>(value);
     Add(data, static_cast<const Value*>(&tmp));
   }
 
  protected:
   // We want the destructor to be completely trivial as to allow it to be
   // a function local static. Hence we make it non-virtual and protected,
   // this class only live as part of a global singleton and should not be
   // deleted.
   ~RepeatedFieldAccessor() = default;
 };
 
 // Implement (Mutable)RepeatedFieldRef::iterator
 template <typename T>
 class RepeatedFieldRefIterator {
   typedef typename RefTypeTraits<T>::AccessorValueType AccessorValueType;
   typedef typename RefTypeTraits<T>::IteratorValueType IteratorValueType;
   typedef typename RefTypeTraits<T>::IteratorPointerType IteratorPointerType;
 
  public:
   using iterator_category = std::forward_iterator_tag;
   using value_type = T;
   using pointer = T*;
   using reference = T&;
   using difference_type = std::ptrdiff_t;
 
   // Constructor for non-message fields.
   RepeatedFieldRefIterator(const void* data,
                            const RepeatedFieldAccessor* accessor, bool begin)
       : data_(data),
         accessor_(accessor),
         iterator_(begin ? accessor->BeginIterator(data)
                         : accessor->EndIterator(data)),
         // The end iterator must not be dereferenced, no need for scratch space.
         scratch_space_(begin ? new AccessorValueType : nullptr) {}
   // Constructor for message fields.
   RepeatedFieldRefIterator(const void* data,
                            const RepeatedFieldAccessor* accessor, bool begin,
                            AccessorValueType* scratch_space)
       : data_(data),
         accessor_(accessor),
         iterator_(begin ? accessor->BeginIterator(data)
                         : accessor->EndIterator(data)),
         scratch_space_(scratch_space) {}
   ~RepeatedFieldRefIterator() { accessor_->DeleteIterator(data_, iterator_); }
   RepeatedFieldRefIterator operator++(int) {
     RepeatedFieldRefIterator tmp(*this);
     iterator_ = accessor_->AdvanceIterator(data_, iterator_);
     return tmp;
   }
   RepeatedFieldRefIterator& operator++() {
     iterator_ = accessor_->AdvanceIterator(data_, iterator_);
     return *this;
   }
   IteratorValueType operator*() const {
     return static_cast<IteratorValueType>(
         *static_cast<const AccessorValueType*>(accessor_->GetIteratorValue(
             data_, iterator_, scratch_space_.get())));
   }
   IteratorPointerType operator->() const {
     return static_cast<IteratorPointerType>(
         accessor_->GetIteratorValue(data_, iterator_, scratch_space_.get()));
   }
   bool operator!=(const RepeatedFieldRefIterator& other) const {
     assert(data_ == other.data_);
     assert(accessor_ == other.accessor_);
     return !accessor_->EqualsIterator(data_, iterator_, other.iterator_);
   }
   bool operator==(const RepeatedFieldRefIterator& other) const {
     return !this->operator!=(other);
   }
 
   RepeatedFieldRefIterator(const RepeatedFieldRefIterator& other)
       : data_(other.data_),
         accessor_(other.accessor_),
         iterator_(accessor_->CopyIterator(data_, other.iterator_)) {}
   RepeatedFieldRefIterator& operator=(const RepeatedFieldRefIterator& other) {
     if (this != &other) {
       accessor_->DeleteIterator(data_, iterator_);
       data_ = other.data_;
       accessor_ = other.accessor_;
       iterator_ = accessor_->CopyIterator(data_, other.iterator_);
     }
     return *this;
   }
 
  protected:
   const void* data_;
   const RepeatedFieldAccessor* accessor_;
   void* iterator_;
   std::unique_ptr<AccessorValueType> scratch_space_;
 };
 
 // TypeTraits that maps the type parameter T of RepeatedFieldRef or
 // MutableRepeatedFieldRef to corresponding iterator type,
 // RepeatedFieldAccessor type, etc.
 template <typename T>
 struct PrimitiveTraits {
   static constexpr bool is_primitive = false;
 };
 #define DEFINE_PRIMITIVE(TYPE, type)                 \
   template <>                                        \
   struct PrimitiveTraits<type> {                     \
     static const bool is_primitive = true;           \
     static const FieldDescriptor::CppType cpp_type = \
         FieldDescriptor::CPPTYPE_##TYPE;             \
   };
 DEFINE_PRIMITIVE(INT32, int32_t)
 DEFINE_PRIMITIVE(UINT32, uint32_t)
 DEFINE_PRIMITIVE(INT64, int64_t)
 DEFINE_PRIMITIVE(UINT64, uint64_t)
 DEFINE_PRIMITIVE(FLOAT, float)
 DEFINE_PRIMITIVE(DOUBLE, double)
 DEFINE_PRIMITIVE(BOOL, bool)
 #undef DEFINE_PRIMITIVE
 
 template <typename T>
 struct RefTypeTraits<
     T, typename std::enable_if<PrimitiveTraits<T>::is_primitive>::type> {
   typedef RepeatedFieldRefIterator<T> iterator;
   typedef RepeatedFieldAccessor AccessorType;
   typedef T AccessorValueType;
   typedef T IteratorValueType;
   typedef T* IteratorPointerType;
   static constexpr FieldDescriptor::CppType cpp_type =
       PrimitiveTraits<T>::cpp_type;
   static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
 };
 
 template <typename T>
 struct RefTypeTraits<
     T, typename std::enable_if<is_proto_enum<T>::value>::type> {
   typedef RepeatedFieldRefIterator<T> iterator;
   typedef RepeatedFieldAccessor AccessorType;
   // We use int32_t for repeated enums in RepeatedFieldAccessor.
   typedef int32_t AccessorValueType;
   typedef T IteratorValueType;
   typedef int32_t* IteratorPointerType;
   static constexpr FieldDescriptor::CppType cpp_type =
       FieldDescriptor::CPPTYPE_ENUM;
   static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
 };
 
 template <typename T>
 struct RefTypeTraits<
     T, typename std::enable_if<std::is_same<std::string, T>::value>::type> {
   typedef RepeatedFieldRefIterator<T> iterator;
   typedef RepeatedFieldAccessor AccessorType;
   typedef std::string AccessorValueType;
   typedef const std::string IteratorValueType;
   typedef const std::string* IteratorPointerType;
   static constexpr FieldDescriptor::CppType cpp_type =
       FieldDescriptor::CPPTYPE_STRING;
   static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
 };
 
 template <typename T>
 struct MessageDescriptorGetter {
   static const Descriptor* get() {
     return T::default_instance().GetDescriptor();
   }
 };
 template <>
 struct MessageDescriptorGetter<Message> {
   static const Descriptor* get() { return nullptr; }
 };
 
 template <typename T>
 struct RefTypeTraits<
     T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
   typedef RepeatedFieldRefIterator<T> iterator;
   typedef RepeatedFieldAccessor AccessorType;
   typedef Message AccessorValueType;
   typedef const T& IteratorValueType;
   typedef const T* IteratorPointerType;
   static constexpr FieldDescriptor::CppType cpp_type =
       FieldDescriptor::CPPTYPE_MESSAGE;
   static const Descriptor* GetMessageFieldDescriptor() {
     return MessageDescriptorGetter<T>::get();
   }
 };
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google
 
 #include "google/protobuf/port_undef.inc"
 
 #endif  // GOOGLE_PROTOBUF_REFLECTION_H__

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